#include <Unit.h>

Inheritance diagram for Unit:

Public Types
typedef std::unordered_set< Unit * >	AttackerSet

typedef std::set< Unit * >	ControlSet

typedef std::multimap< uint32, Aura * >	AuraMap

typedef std::pair< AuraMap::const_iterator, AuraMap::const_iterator >	AuraMapBounds

typedef std::pair< AuraMap::iterator, AuraMap::iterator >	AuraMapBoundsNonConst

typedef std::multimap< uint32, AuraApplication * >	AuraApplicationMap

typedef std::pair< AuraApplicationMap::const_iterator, AuraApplicationMap::const_iterator >	AuraApplicationMapBounds

typedef std::pair< AuraApplicationMap::iterator, AuraApplicationMap::iterator >	AuraApplicationMapBoundsNonConst

typedef std::multimap< AuraStateType, AuraApplication * >	AuraStateAurasMap

typedef std::pair< AuraStateAurasMap::const_iterator, AuraStateAurasMap::const_iterator >	AuraStateAurasMapBounds

typedef std::list< AuraEffect * >	AuraEffectList

typedef std::list< Aura * >	AuraList

typedef std::list< AuraApplication * >	AuraApplicationList

typedef std::list< DiminishingReturn >	Diminishing

typedef GuidUnorderedSet	ComboPointHolderSet

typedef std::map< uint8, AuraApplication * >	VisibleAuraMap

typedef std::set< PetAura const * >	PetAuraSet

Public Member Functions
	~Unit () override

UnitAI *	GetAI ()

void	SetAI (UnitAI *newAI)

void	AddToWorld () override

void	RemoveFromWorld () override

void	CleanupBeforeRemoveFromMap (bool finalCleanup)

void	CleanupsBeforeDelete (bool finalCleanup=true) override

uint32	GetDynamicFlags () const override

void	ReplaceAllDynamicFlags (uint32 flag) override

DiminishingLevels	GetDiminishing (DiminishingGroup group)

void	IncrDiminishing (DiminishingGroup group)

float	ApplyDiminishingToDuration (DiminishingGroup group, int32 &duration, Unit *caster, DiminishingLevels Level, int32 limitduration)

void	ApplyDiminishingAura (DiminishingGroup group, bool apply)

void	ClearDiminishings ()

float	GetSpellMaxRangeForTarget (Unit const target, SpellInfo const spellInfo) const

float	GetSpellMinRangeForTarget (Unit const target, SpellInfo const spellInfo) const

void	Update (uint32 time) override

void	setAttackTimer (WeaponAttackType type, int32 time)

void	resetAttackTimer (WeaponAttackType type=BASE_ATTACK)

int32	getAttackTimer (WeaponAttackType type) const

bool	isAttackReady (WeaponAttackType type=BASE_ATTACK) const

bool	haveOffhandWeapon () const

bool	CanDualWield () const

virtual void	SetCanDualWield (bool value)

float	GetCombatReach () const override

float	GetMeleeReach () const

bool	IsWithinRange (Unit const *obj, float dist) const

bool	IsWithinCombatRange (Unit const *obj, float dist2compare) const

bool	IsWithinMeleeRange (Unit const *obj, float dist=0.f) const

float	GetMeleeRange (Unit const *target) const

virtual SpellSchoolMask	GetMeleeDamageSchoolMask (WeaponAttackType attackType=BASE_ATTACK, uint8 damageIndex=0) const =0

bool	GetRandomContactPoint (Unit const *target, float &x, float &y, float &z, bool force=false) const

void	_addAttacker (Unit *pAttacker)

void	_removeAttacker (Unit *pAttacker)

Unit *	getAttackerForHelper () const

bool	Attack (Unit *victim, bool meleeAttack)

void	CastStop (uint32 except_spellid=0, bool withInstant=true)

bool	AttackStop ()

void	RemoveAllAttackers ()

AttackerSet const &	getAttackers () const

bool	GetMeleeAttackPoint (Unit *attacker, Position &pos)

bool	isAttackingPlayer () const

Unit *	GetVictim () const

void	CombatStop (bool includingCast=false)

void	CombatStopWithPets (bool includingCast=false)

void	StopAttackFaction (uint32 faction_id)

void	StopAttackingInvalidTarget ()

Unit *	SelectNearbyTarget (Unit *exclude=nullptr, float dist=NOMINAL_MELEE_RANGE) const

Unit *	SelectNearbyNoTotemTarget (Unit *exclude=nullptr, float dist=NOMINAL_MELEE_RANGE) const

void	SendMeleeAttackStop (Unit *victim=nullptr)

void	SendMeleeAttackStart (Unit victim, Player sendTo=nullptr)

void	AddUnitState (uint32 f)

bool	HasUnitState (const uint32 f) const

void	ClearUnitState (uint32 f)

uint32	GetUnitState () const

bool	CanFreeMove () const

uint32	HasUnitTypeMask (uint32 mask) const

void	AddUnitTypeMask (uint32 mask)

uint32	GetUnitTypeMask () const

bool	IsSummon () const

bool	IsGuardian () const

bool	IsControllableGuardian () const

bool	IsPet () const

bool	IsHunterPet () const

bool	IsTotem () const

bool	IsVehicle () const

uint8	getLevel () const

uint8	getLevelForTarget (WorldObject const *) const override

void	SetLevel (uint8 lvl, bool showLevelChange=true)

uint8	getRace (bool original=false) const

void	setRace (uint8 race)

uint32	getRaceMask () const

uint8	getClass () const

uint32	getClassMask () const

uint8	getGender () const

float	GetStat (Stats stat) const

void	SetStat (Stats stat, int32 val)

uint32	GetArmor () const

void	SetArmor (int32 val)

uint32	GetResistance (SpellSchools school) const

uint32	GetResistance (SpellSchoolMask mask) const

void	SetResistance (SpellSchools school, int32 val)

uint32	GetHealth () const

uint32	GetMaxHealth () const

bool	IsFullHealth () const

bool	HealthBelowPct (int32 pct) const

bool	HealthBelowPctDamaged (int32 pct, uint32 damage) const

bool	HealthAbovePct (int32 pct) const

bool	HealthAbovePctHealed (int32 pct, uint32 heal) const

float	GetHealthPct () const

uint32	CountPctFromMaxHealth (int32 pct) const

uint32	CountPctFromCurHealth (int32 pct) const

float	GetPowerPct (Powers power) const

void	SetHealth (uint32 val)

void	SetMaxHealth (uint32 val)

void	SetFullHealth ()

int32	ModifyHealth (int32 val)

int32	GetHealthGain (int32 dVal)

Powers	getPowerType () const

void	setPowerType (Powers power)

uint32	GetPower (Powers power) const

uint32	GetMaxPower (Powers power) const

void	SetPower (Powers power, uint32 val, bool withPowerUpdate=true)

void	SetMaxPower (Powers power, uint32 val)

int32	ModifyPower (Powers power, int32 val, bool withPowerUpdate=true)

int32	ModifyPowerPct (Powers power, float pct, bool apply=true)

uint32	GetAttackTime (WeaponAttackType att) const

void	SetAttackTime (WeaponAttackType att, uint32 val)

void	ApplyAttackTimePercentMod (WeaponAttackType att, float val, bool apply)

void	ApplyCastTimePercentMod (float val, bool apply)

UnitFlags	GetUnitFlags () const

bool	HasUnitFlag (UnitFlags flags) const

void	SetUnitFlag (UnitFlags flags)

void	RemoveUnitFlag (UnitFlags flags)

void	ReplaceAllUnitFlags (UnitFlags flags)

UnitFlags2	GetUnitFlags2 () const

bool	HasUnitFlag2 (UnitFlags2 flags) const

void	SetUnitFlag2 (UnitFlags2 flags)

void	RemoveUnitFlag2 (UnitFlags2 flags)

void	ReplaceAllUnitFlags2 (UnitFlags2 flags)

SheathState	GetSheath () const

virtual void	SetSheath (SheathState sheathed)

uint32	GetFaction () const

void	SetFaction (uint32 faction)

FactionTemplateEntry const *	GetFactionTemplateEntry () const

ReputationRank	GetReactionTo (Unit const *target, bool checkOriginalFaction=false) const

ReputationRank	GetFactionReactionTo (FactionTemplateEntry const factionTemplateEntry, Unit const target) const

bool	IsHostileTo (Unit const *unit) const

bool	IsHostileToPlayers () const

bool	IsFriendlyTo (Unit const *unit) const

bool	IsNeutralToAll () const

bool	IsInPartyWith (Unit const *unit) const

bool	IsInRaidWith (Unit const *unit) const

void	GetPartyMembers (std::list< Unit * > &units)

bool	IsContestedGuard () const

bool	IsInSanctuary () const

bool	IsPvP () const

bool	IsFFAPvP () const

void	SetPvP (bool state)

uint32	GetCreatureType () const

uint32	GetCreatureTypeMask () const

uint8	getStandState () const

bool	IsSitState () const

bool	IsStandState () const

void	SetStandState (uint8 state)

void	SetStandFlags (uint8 flags)

void	RemoveStandFlags (uint8 flags)

bool	IsMounted () const

uint32	GetMountID () const

void	Mount (uint32 mount, uint32 vehicleId=0, uint32 creatureEntry=0)

void	Dismount ()

uint16	GetMaxSkillValueForLevel (Unit const *target=nullptr) const

void	ProcDamageAndSpellFor (bool isVictim, Unit target, uint32 procFlag, uint32 procExtra, WeaponAttackType attType, SpellInfo const procSpellInfo, uint32 damage, SpellInfo const procAura=nullptr, int8 procAuraEffectIndex=-1, Spell const procSpell=nullptr, DamageInfo damageInfo=nullptr, HealInfo healInfo=nullptr, uint32 procPhase=2)

void	GetProcAurasTriggeredOnEvent (std::list< AuraApplication * > &aurasTriggeringProc, std::list< AuraApplication * > *procAuras, ProcEventInfo eventInfo)

void	TriggerAurasProcOnEvent (CalcDamageInfo &damageInfo)

void	TriggerAurasProcOnEvent (std::list< AuraApplication * > myProcAuras, std::list< AuraApplication > targetProcAuras, Unit actionTarget, uint32 typeMaskActor, uint32 typeMaskActionTarget, uint32 spellTypeMask, uint32 spellPhaseMask, uint32 hitMask, Spell spell, DamageInfo damageInfo, HealInfo *healInfo)

void	TriggerAurasProcOnEvent (ProcEventInfo &eventInfo, std::list< AuraApplication * > &procAuras)

void	HandleEmoteCommand (uint32 emoteId)

void	AttackerStateUpdate (Unit *victim, WeaponAttackType attType=BASE_ATTACK, bool extra=false, bool ignoreCasting=false)

void	CalculateMeleeDamage (Unit victim, CalcDamageInfo damageInfo, WeaponAttackType attackType=BASE_ATTACK, const bool sittingVictim=false)

void	DealMeleeDamage (CalcDamageInfo *damageInfo, bool durabilityLoss)

void	HandleProcExtraAttackFor (Unit *victim, uint32 count)

void	SetLastExtraAttackSpell (uint32 spellId)

uint32	GetLastExtraAttackSpell () const

void	AddExtraAttacks (uint32 count)

void	SetLastDamagedTargetGuid (ObjectGuid const &guid)

ObjectGuid const &	GetLastDamagedTargetGuid () const

void	CalculateSpellDamageTaken (SpellNonMeleeDamage damageInfo, int32 damage, SpellInfo const spellInfo, WeaponAttackType attackType=BASE_ATTACK, bool crit=false)

void	DealSpellDamage (SpellNonMeleeDamage damageInfo, bool durabilityLoss, Spell const spell=nullptr)

float	GetMeleeCritChanceReduction () const

float	GetRangedCritChanceReduction () const

float	GetSpellCritChanceReduction () const

uint32	GetMeleeCritDamageReduction (uint32 damage) const

uint32	GetRangedCritDamageReduction (uint32 damage) const

uint32	GetSpellCritDamageReduction (uint32 damage) const

uint32	GetMeleeDamageReduction (uint32 damage) const

uint32	GetRangedDamageReduction (uint32 damage) const

uint32	GetSpellDamageReduction (uint32 damage) const

float	MeleeSpellMissChance (Unit const *victim, WeaponAttackType attType, int32 skillDiff, uint32 spellId) const

SpellMissInfo	MeleeSpellHitResult (Unit victim, SpellInfo const spell)

SpellMissInfo	MagicSpellHitResult (Unit victim, SpellInfo const spell)

SpellMissInfo	SpellHitResult (Unit victim, SpellInfo const spell, bool canReflect=false)

SpellMissInfo	SpellHitResult (Unit victim, Spell const spell, bool canReflect=false)

float	GetUnitDodgeChance () const

float	GetUnitParryChance () const

float	GetUnitBlockChance () const

float	GetUnitMissChance (WeaponAttackType attType) const

float	GetUnitCriticalChance (WeaponAttackType attackType, Unit const *victim) const

int32	GetMechanicResistChance (SpellInfo const *spell)

bool	CanUseAttackType (uint8 attacktype) const

virtual uint32	GetShieldBlockValue () const =0

uint32	GetShieldBlockValue (uint32 soft_cap, uint32 hard_cap) const

uint32	GetUnitMeleeSkill (Unit const *target=nullptr) const

uint32	GetDefenseSkillValue (Unit const *target=nullptr) const

uint32	GetWeaponSkillValue (WeaponAttackType attType, Unit const *target=nullptr) const

float	GetWeaponProcChance () const

float	GetPPMProcChance (uint32 WeaponSpeed, float PPM, SpellInfo const *spellProto) const

MeleeHitOutcome	RollMeleeOutcomeAgainst (Unit const *victim, WeaponAttackType attType) const

MeleeHitOutcome	RollMeleeOutcomeAgainst (Unit const *victim, WeaponAttackType attType, int32 crit_chance, int32 miss_chance, int32 dodge_chance, int32 parry_chance, int32 block_chance) const

NPCFlags	GetNpcFlags () const

bool	HasNpcFlag (NPCFlags flags) const

void	SetNpcFlag (NPCFlags flags)

void	RemoveNpcFlag (NPCFlags flags)

void	ReplaceAllNpcFlags (NPCFlags flags)

bool	IsVendor () const

bool	IsTrainer () const

bool	IsQuestGiver () const

bool	IsGossip () const

bool	IsTaxi () const

bool	IsGuildMaster () const

bool	IsBattleMaster () const

bool	IsBanker () const

bool	IsInnkeeper () const

bool	IsSpiritHealer () const

bool	IsSpiritGuide () const

bool	IsTabardDesigner () const

bool	IsAuctioner () const

bool	IsArmorer () const

bool	IsServiceProvider () const

bool	IsSpiritService () const

bool	IsCritter () const

bool	IsInFlight () const

void	SetImmuneToAll (bool apply, bool keepCombat=false)

bool	IsImmuneToAll () const

void	SetImmuneToPC (bool apply, bool keepCombat=false)

bool	IsImmuneToPC () const

void	SetImmuneToNPC (bool apply, bool keepCombat=false)

bool	IsImmuneToNPC () const

bool	IsEngaged () const

bool	IsEngagedBy (Unit const *who) const

bool	IsInCombat () const

bool	IsInCombatWith (Unit const *who) const

bool	IsPetInCombat () const

void	CombatStart (Unit *target, bool initialAggro=true)

void	CombatStartOnCast (Unit *target, bool initialAggro=true, uint32 duration=0)

void	SetInCombatState (bool PvP, Unit *enemy=nullptr, uint32 duration=0)

void	SetInCombatWith (Unit *enemy, uint32 duration=0)

void	ClearInCombat ()

void	ClearInPetCombat ()

uint32	GetCombatTimer () const

void	SetCombatTimer (uint32 timer)

bool	HasAuraTypeWithFamilyFlags (AuraType auraType, uint32 familyName, uint32 familyFlags) const

virtual bool	HasSpell (uint32) const

bool	HasBreakableByDamageAuraType (AuraType type, uint32 excludeAura=0) const

bool	HasBreakableByDamageCrowdControlAura (Unit *excludeCasterChannel=nullptr) const

bool	HasStealthAura () const

bool	HasInvisibilityAura () const

bool	isFeared () const

bool	isInRoots () const

bool	IsPolymorphed () const

bool	isFrozen () const

bool	isTargetableForAttack (bool checkFakeDeath=true, Unit const *byWho=nullptr) const

bool	IsValidAttackTarget (Unit const *target) const

bool	_IsValidAttackTarget (Unit const target, SpellInfo const bySpell, WorldObject const *obj=nullptr) const

bool	IsValidAssistTarget (Unit const *target) const

bool	_IsValidAssistTarget (Unit const target, SpellInfo const bySpell) const

virtual bool	IsInWater () const

virtual bool	IsUnderWater () const

bool	isInAccessiblePlaceFor (Creature const *c) const

void	SendHealSpellLog (Unit *victim, uint32 SpellID, uint32 Damage, uint32 OverHeal, uint32 Absorb, bool critical=false)

int32	HealBySpell (HealInfo &healInfo, bool critical=false)

void	SendEnergizeSpellLog (Unit *victim, uint32 SpellID, uint32 Damage, Powers powertype)

void	EnergizeBySpell (Unit *victim, uint32 SpellID, uint32 Damage, Powers powertype)

SpellCastResult	CastSpell (SpellCastTargets const &targets, SpellInfo const spellInfo, CustomSpellValues const value, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (Unit victim, uint32 spellId, bool triggered, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (Unit victim, uint32 spellId, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (Unit victim, SpellInfo const spellInfo, bool triggered, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (Unit victim, SpellInfo const spellInfo, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (float x, float y, float z, uint32 spellId, bool triggered, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (GameObject go, uint32 spellId, bool triggered, Item castItem=nullptr, AuraEffect *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastCustomSpell (Unit victim, uint32 spellId, int32 const bp0, int32 const bp1, int32 const bp2, bool triggered, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastCustomSpell (uint32 spellId, SpellValueMod mod, int32 value, Unit victim, bool triggered, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastCustomSpell (uint32 spellId, SpellValueMod mod, int32 value, Unit victim=nullptr, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastCustomSpell (uint32 spellId, CustomSpellValues const &value, Unit victim=nullptr, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

Aura *	AddAura (uint32 spellId, Unit *target)

Aura *	AddAura (SpellInfo const spellInfo, uint8 effMask, Unit target)

void	SetAuraStack (uint32 spellId, Unit *target, uint32 stack)

void	SendPlaySpellVisual (uint32 id)

void	SendPlaySpellImpact (ObjectGuid guid, uint32 id)

void	BuildCooldownPacket (WorldPacket &data, uint8 flags, uint32 spellId, uint32 cooldown)

void	BuildCooldownPacket (WorldPacket &data, uint8 flags, PacketCooldowns const &cooldowns)

void	DeMorph ()

void	SendAttackStateUpdate (CalcDamageInfo *damageInfo)

void	SendAttackStateUpdate (uint32 HitInfo, Unit *target, uint8 SwingType, SpellSchoolMask damageSchoolMask, uint32 Damage, uint32 AbsorbDamage, uint32 Resist, VictimState TargetState, uint32 BlockedAmount)

void	SendSpellNonMeleeDamageLog (SpellNonMeleeDamage *log)

void	SendSpellNonMeleeReflectLog (SpellNonMeleeDamage log, Unit attacker)

void	SendSpellNonMeleeDamageLog (Unit target, SpellInfo const spellInfo, uint32 Damage, SpellSchoolMask damageSchoolMask, uint32 AbsorbedDamage, uint32 Resist, bool PhysicalDamage, uint32 Blocked, bool CriticalHit=false, bool Split=false)

void	SendPeriodicAuraLog (SpellPeriodicAuraLogInfo *pInfo)

void	SendSpellMiss (Unit *target, uint32 spellID, SpellMissInfo missInfo)

void	SendSpellDamageResist (Unit *target, uint32 spellId)

void	SendSpellDamageImmune (Unit *target, uint32 spellId)

void	NearTeleportTo (Position &pos, bool casting=false, bool vehicleTeleport=false, bool withPet=false, bool removeTransport=false)

void	NearTeleportTo (float x, float y, float z, float orientation, bool casting=false, bool vehicleTeleport=false, bool withPet=false, bool removeTransport=false)

void	SendTameFailure (uint8 result)

void	SendTeleportPacket (Position &pos)

virtual bool	UpdatePosition (float x, float y, float z, float ang, bool teleport=false)

bool	UpdatePosition (const Position &pos, bool teleport=false)

void	UpdateOrientation (float orientation)
	Only server-side orientation update, does not broadcast to client. More...

void	UpdateHeight (float newZ)
	Only server-side height update, does not broadcast to client. More...

void	KnockbackFrom (float x, float y, float speedXY, float speedZ)

void	JumpTo (float speedXY, float speedZ, bool forward=true)

void	JumpTo (WorldObject *obj, float speedZ)

void	SendMonsterMove (float NewPosX, float NewPosY, float NewPosZ, uint32 TransitTime, SplineFlags sf=SPLINEFLAG_WALK_MODE)

void	MonsterMoveWithSpeed (float x, float y, float z, float speed)

void	SendMovementFlagUpdate (bool self=false)

virtual bool	SetWalk (bool enable)

virtual bool	SetDisableGravity (bool disable, bool packetOnly=false, bool updateAnimationTier=true)

virtual bool	SetSwim (bool enable)

virtual bool	SetCanFly (bool enable, bool packetOnly=false)

virtual bool	SetWaterWalking (bool enable, bool packetOnly=false)

virtual bool	SetFeatherFall (bool enable, bool packetOnly=false)

virtual bool	SetHover (bool enable, bool packetOnly=false, bool updateAnimationTier=true)

void	SendMovementWaterWalking (Player *sendTo)

void	SendMovementFeatherFall (Player *sendTo)

void	SendMovementHover (Player *sendTo)

void	SetInFront (WorldObject const *target)

void	SetFacingTo (float ori)

void	SetFacingToObject (WorldObject *object)

void	SendChangeCurrentVictimOpcode (HostileReference *pHostileReference)

void	SendClearThreatListOpcode ()

void	SendRemoveFromThreatListOpcode (HostileReference *pHostileReference)

void	SendThreatListUpdate ()

void	SendClearTarget ()

void	BuildHeartBeatMsg (WorldPacket *data) const

bool	IsAlive () const

bool	isDying () const

bool	isDead () const

DeathState	getDeathState ()

virtual void	setDeathState (DeathState s, bool despawn=false)

ObjectGuid	GetOwnerGUID () const

void	SetOwnerGUID (ObjectGuid owner)

ObjectGuid	GetCreatorGUID () const

void	SetCreatorGUID (ObjectGuid creator)

ObjectGuid	GetMinionGUID () const

void	SetMinionGUID (ObjectGuid guid)

ObjectGuid	GetCharmerGUID () const

void	SetCharmerGUID (ObjectGuid owner)

ObjectGuid	GetCharmGUID () const

void	SetPetGUID (ObjectGuid guid)

ObjectGuid	GetPetGUID () const

void	SetCritterGUID (ObjectGuid guid)

ObjectGuid	GetCritterGUID () const

bool	IsControlledByPlayer () const

bool	IsCreatedByPlayer () const

ObjectGuid	GetCharmerOrOwnerGUID () const

ObjectGuid	GetCharmerOrOwnerOrOwnGUID () const

bool	IsCharmedOwnedByPlayerOrPlayer () const

Player *	GetSpellModOwner () const

Unit *	GetOwner () const

Guardian *	GetGuardianPet () const

Minion *	GetFirstMinion () const

Unit *	GetCharmer () const

Unit *	GetCharm () const

Unit *	GetCharmerOrOwner () const

Unit *	GetCharmerOrOwnerOrSelf () const

Player *	GetCharmerOrOwnerPlayerOrPlayerItself () const

Player *	GetAffectingPlayer () const

void	SetMinion (Minion *minion, bool apply)

void	GetAllMinionsByEntry (std::list< Creature * > &Minions, uint32 entry)

void	RemoveAllMinionsByEntry (uint32 entry)

void	SetCharm (Unit *target, bool apply)

Unit *	GetNextRandomRaidMemberOrPet (float radius)

bool	SetCharmedBy (Unit charmer, CharmType type, AuraApplication const aurApp=nullptr)

void	RemoveCharmedBy (Unit *charmer)

void	RestoreFaction ()

Unit *	GetFirstControlled () const

void	RemoveAllControlled (bool onDeath=false)

bool	IsCharmed () const

bool	isPossessed () const

bool	isPossessedByPlayer () const

bool	isPossessing () const

bool	isPossessing (Unit *u) const

CharmInfo *	GetCharmInfo ()

CharmInfo *	InitCharmInfo ()

void	DeleteCharmInfo ()

void	UpdateCharmAI ()

SharedVisionList const &	GetSharedVisionList ()

void	AddPlayerToVision (Player *player)

void	RemovePlayerFromVision (Player *player)

bool	HasSharedVision () const

void	RemoveBindSightAuras ()

void	RemoveCharmAuras ()

Pet *	CreateTamedPetFrom (Creature *creatureTarget, uint32 spell_id=0)

Pet *	CreateTamedPetFrom (uint32 creatureEntry, uint32 spell_id=0)

bool	InitTamedPet (Pet *pet, uint8 level, uint32 spell_id)

Aura *	_TryStackingOrRefreshingExistingAura (SpellInfo const newAura, uint8 effMask, Unit caster, int32 baseAmount=nullptr, Item castItem=nullptr, ObjectGuid casterGUID=ObjectGuid::Empty, bool periodicReset=false)

void	_AddAura (UnitAura aura, Unit caster)

AuraApplication *	_CreateAuraApplication (Aura *aura, uint8 effMask)

void	_ApplyAuraEffect (Aura *aura, uint8 effIndex)

void	_ApplyAura (AuraApplication *aurApp, uint8 effMask)

void	_UnapplyAura (AuraApplicationMap::iterator &i, AuraRemoveMode removeMode)

void	_UnapplyAura (AuraApplication *aurApp, AuraRemoveMode removeMode)

void	_RemoveNoStackAuraApplicationsDueToAura (Aura *aura)

void	_RemoveNoStackAurasDueToAura (Aura *aura)

bool	_IsNoStackAuraDueToAura (Aura appliedAura, Aura existingAura) const

void	_RegisterAuraEffect (AuraEffect *aurEff, bool apply)

AuraMap &	GetOwnedAuras ()

AuraMap const &	GetOwnedAuras () const

void	RemoveOwnedAura (AuraMap::iterator &i, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveOwnedAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveOwnedAura (Aura *aura, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

Aura *	GetOwnedAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, Aura *except=nullptr) const

AuraApplicationMap &	GetAppliedAuras ()

AuraApplicationMap const &	GetAppliedAuras () const

void	RemoveAura (AuraApplicationMap::iterator &i, AuraRemoveMode mode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAura (AuraApplication *aurApp, AuraRemoveMode mode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAura (Aura *aur, AuraRemoveMode mode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAppliedAuras (std::function< bool(AuraApplication const *)> const &check)

void	RemoveOwnedAuras (std::function< bool(Aura const *)> const &check)

void	RemoveAppliedAuras (uint32 spellId, std::function< bool(AuraApplication const *)> const &check)

void	RemoveOwnedAuras (uint32 spellId, std::function< bool(Aura const *)> const &check)

void	RemoveAurasDueToSpell (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAuraFromStack (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAurasDueToSpellByDispel (uint32 spellId, uint32 dispellerSpellId, ObjectGuid casterGUID, Unit *dispeller, uint8 chargesRemoved=1)

void	RemoveAurasDueToSpellBySteal (uint32 spellId, ObjectGuid casterGUID, Unit *stealer)

void	RemoveAurasDueToItemSpell (uint32 spellId, ObjectGuid castItemGuid)

void	RemoveAurasByType (AuraType auraType, ObjectGuid casterGUID=ObjectGuid::Empty, Aura *except=nullptr, bool negative=true, bool positive=true)

void	RemoveNotOwnSingleTargetAuras ()

void	RemoveAurasWithInterruptFlags (uint32 flag, uint32 except=0, bool isAutoshot=false)

void	RemoveAurasWithAttribute (uint32 flags)

void	RemoveAurasWithFamily (SpellFamilyNames family, uint32 familyFlag1, uint32 familyFlag2, uint32 familyFlag3, ObjectGuid casterGUID)

void	RemoveAurasWithMechanic (uint32 mechanic_mask, AuraRemoveMode removemode=AURA_REMOVE_BY_DEFAULT, uint32 except=0)

void	RemoveMovementImpairingAuras (bool withRoot)

void	RemoveAurasByShapeShift ()

void	RemoveAreaAurasDueToLeaveWorld ()

void	RemoveAllAuras ()

void	RemoveArenaAuras ()

void	RemoveAllAurasOnDeath ()

void	RemoveAllAurasRequiringDeadTarget ()

void	RemoveAllAurasExceptType (AuraType type)

void	RemoveEvadeAuras ()

void	DelayOwnedAuras (uint32 spellId, ObjectGuid caster, int32 delaytime)

void	_RemoveAllAuraStatMods ()

void	_ApplyAllAuraStatMods ()

AuraEffectList const &	GetAuraEffectsByType (AuraType type) const

AuraList &	GetSingleCastAuras ()

AuraList const &	GetSingleCastAuras () const

AuraEffect *	GetAuraEffect (uint32 spellId, uint8 effIndex, ObjectGuid casterGUID=ObjectGuid::Empty) const

AuraEffect *	GetAuraEffectOfRankedSpell (uint32 spellId, uint8 effIndex, ObjectGuid casterGUID=ObjectGuid::Empty) const

AuraEffect *	GetAuraEffect (AuraType type, SpellFamilyNames name, uint32 iconId, uint8 effIndex) const

AuraEffect *	GetAuraEffect (AuraType type, SpellFamilyNames family, uint32 familyFlag1, uint32 familyFlag2, uint32 familyFlag3, ObjectGuid casterGUID=ObjectGuid::Empty) const

AuraEffect *	GetAuraEffectDummy (uint32 spellid) const

AuraEffect *	GetDummyAuraEffect (SpellFamilyNames name, uint32 iconId, uint8 effIndex) const

AuraApplication *	GetAuraApplication (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraApplication *except=nullptr) const

Aura *	GetAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0) const

AuraApplication *	GetAuraApplicationOfRankedSpell (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraApplication *except=nullptr) const

Aura *	GetAuraOfRankedSpell (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0) const

void	GetDispellableAuraList (Unit *caster, uint32 dispelMask, DispelChargesList &dispelList)

bool	HasAuraEffect (uint32 spellId, uint8 effIndex, ObjectGuid caster=ObjectGuid::Empty) const

uint32	GetAuraCount (uint32 spellId) const

bool	HasAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0) const

bool	HasAuraType (AuraType auraType) const

bool	HasAuraTypeWithCaster (AuraType auratype, ObjectGuid caster) const

bool	HasAuraTypeWithMiscvalue (AuraType auratype, int32 miscvalue) const

bool	HasAuraTypeWithAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

bool	HasAuraTypeWithValue (AuraType auratype, int32 value) const

bool	HasAuraTypeWithTriggerSpell (AuraType auratype, uint32 triggerSpell) const

bool	HasNegativeAuraWithInterruptFlag (uint32 flag, ObjectGuid guid=ObjectGuid::Empty)

bool	HasVisibleAuraType (AuraType auraType) const

bool	HasNegativeAuraWithAttribute (uint32 flag, ObjectGuid guid=ObjectGuid::Empty)

bool	HasAuraWithMechanic (uint32 mechanicMask) const

AuraEffect *	IsScriptOverriden (SpellInfo const *spell, int32 script) const

uint32	GetDiseasesByCaster (ObjectGuid casterGUID, uint8 mode=0)

uint32	GetDoTsByCaster (ObjectGuid casterGUID) const

int32	GetTotalAuraModifierAreaExclusive (AuraType auratype) const

int32	GetTotalAuraModifier (AuraType auratype) const

float	GetTotalAuraMultiplier (AuraType auratype) const

int32	GetMaxPositiveAuraModifier (AuraType auratype)

int32	GetMaxNegativeAuraModifier (AuraType auratype) const

int32	GetTotalAuraModifierByMiscMask (AuraType auratype, uint32 misc_mask) const

float	GetTotalAuraMultiplierByMiscMask (AuraType auratype, uint32 misc_mask) const

int32	GetMaxPositiveAuraModifierByMiscMask (AuraType auratype, uint32 misc_mask, const AuraEffect *except=nullptr) const

int32	GetMaxNegativeAuraModifierByMiscMask (AuraType auratype, uint32 misc_mask) const

int32	GetTotalAuraModifierByMiscValue (AuraType auratype, int32 misc_value) const

float	GetTotalAuraMultiplierByMiscValue (AuraType auratype, int32 misc_value) const

int32	GetMaxPositiveAuraModifierByMiscValue (AuraType auratype, int32 misc_value) const

int32	GetMaxNegativeAuraModifierByMiscValue (AuraType auratype, int32 misc_value) const

int32	GetTotalAuraModifierByAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

float	GetTotalAuraMultiplierByAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

int32	GetMaxPositiveAuraModifierByAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

int32	GetMaxNegativeAuraModifierByAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

float	GetResistanceBuffMods (SpellSchools school, bool positive) const

void	SetResistanceBuffMods (SpellSchools school, bool positive, float val)

void	ApplyResistanceBuffModsMod (SpellSchools school, bool positive, float val, bool apply)

void	ApplyResistanceBuffModsPercentMod (SpellSchools school, bool positive, float val, bool apply)

void	InitStatBuffMods ()

void	ApplyStatBuffMod (Stats stat, float val, bool apply)

void	ApplyStatPercentBuffMod (Stats stat, float val, bool apply)

void	SetCreateStat (Stats stat, float val)

void	SetCreateHealth (uint32 val)

uint32	GetCreateHealth () const

void	SetCreateMana (uint32 val)

uint32	GetCreateMana () const

uint32	GetCreatePowers (Powers power) const

float	GetPosStat (Stats stat) const

float	GetNegStat (Stats stat) const

float	GetCreateStat (Stats stat) const

void	SetCurrentCastedSpell (Spell *pSpell)

virtual void	ProhibitSpellSchool (SpellSchoolMask, uint32)

void	InterruptSpell (CurrentSpellTypes spellType, bool withDelayed=true, bool withInstant=true, bool bySelf=false)

void	FinishSpell (CurrentSpellTypes spellType, bool ok=true)

bool	IsNonMeleeSpellCast (bool withDelayed, bool skipChanneled=false, bool skipAutorepeat=false, bool isAutoshoot=false, bool skipInstant=true) const

void	InterruptNonMeleeSpells (bool withDelayed, uint32 spellid=0, bool withInstant=true, bool bySelf=false)

Spell *	GetCurrentSpell (CurrentSpellTypes spellType) const

Spell *	GetCurrentSpell (uint32 spellType) const

Spell *	FindCurrentSpellBySpellId (uint32 spell_id) const

int32	GetCurrentSpellCastTime (uint32 spell_id) const

virtual bool	IsMovementPreventedByCasting () const

ShapeshiftForm	GetShapeshiftForm () const

void	SetShapeshiftForm (ShapeshiftForm form)

bool	IsInFeralForm () const

bool	IsInDisallowedMountForm () const

bool	HandleStatModifier (UnitMods unitMod, UnitModifierType modifierType, float amount, bool apply)

void	SetModifierValue (UnitMods unitMod, UnitModifierType modifierType, float value)

float	GetModifierValue (UnitMods unitMod, UnitModifierType modifierType) const

float	GetTotalStatValue (Stats stat, float additionalValue=0.0f) const

float	GetTotalAuraModValue (UnitMods unitMod) const

SpellSchools	GetSpellSchoolByAuraGroup (UnitMods unitMod) const

Stats	GetStatByAuraGroup (UnitMods unitMod) const

Powers	GetPowerTypeByAuraGroup (UnitMods unitMod) const

bool	CanModifyStats () const

void	SetCanModifyStats (bool modifyStats)

virtual bool	UpdateStats (Stats stat)=0

virtual bool	UpdateAllStats ()=0

virtual void	UpdateResistances (uint32 school)=0

virtual void	UpdateAllResistances ()

virtual void	UpdateArmor ()=0

virtual void	UpdateMaxHealth ()=0

virtual void	UpdateMaxPower (Powers power)=0

virtual void	UpdateAttackPowerAndDamage (bool ranged=false)=0

virtual void	UpdateDamagePhysical (WeaponAttackType attType)

float	GetTotalAttackPowerValue (WeaponAttackType attType, Unit *pVictim=nullptr) const

float	GetWeaponDamageRange (WeaponAttackType attType, WeaponDamageRange type, uint8 damageIndex=0) const

void	SetBaseWeaponDamage (WeaponAttackType attType, WeaponDamageRange damageRange, float value, uint8 damageIndex=0)

virtual void	CalculateMinMaxDamage (WeaponAttackType attType, bool normalized, bool addTotalPct, float &minDamage, float &maxDamage, uint8 damageIndex=0)=0

uint32	CalculateDamage (WeaponAttackType attType, bool normalized, bool addTotalPct, uint8 itemDamagesMask=0)

float	GetAPMultiplier (WeaponAttackType attType, bool normalized)

bool	isInFrontInMap (Unit const *target, float distance, float arc=M_PI) const

bool	isInBackInMap (Unit const *target, float distance, float arc=M_PI) const

bool	IsVisible () const

void	SetVisible (bool x)

void	SetModelVisible (bool on)

uint32	GetPhaseByAuras () const

void	SetPhaseMask (uint32 newPhaseMask, bool update) override

void	UpdateObjectVisibility (bool forced=true, bool fromUpdate=false) override

bool	CanHaveThreatList () const

void	AddThreat (Unit victim, float fThreat, SpellSchoolMask schoolMask=SPELL_SCHOOL_MASK_NORMAL, SpellInfo const threatSpell=nullptr)

float	ApplyTotalThreatModifier (float fThreat, SpellSchoolMask schoolMask=SPELL_SCHOOL_MASK_NORMAL)

void	TauntApply (Unit *victim)

void	TauntFadeOut (Unit *taunter)

ThreatMgr &	GetThreatMgr ()

ThreatMgr const &	GetThreatMgr () const

void	addHatedBy (HostileReference *pHostileReference)

void	removeHatedBy (HostileReference *)

HostileRefMgr &	getHostileRefMgr ()

VisibleAuraMap const *	GetVisibleAuras ()

AuraApplication *	GetVisibleAura (uint8 slot)

void	SetVisibleAura (uint8 slot, AuraApplication *aur)

void	RemoveVisibleAura (uint8 slot)

uint32	GetInterruptMask () const

void	AddInterruptMask (uint32 mask)

void	UpdateInterruptMask ()

uint32	GetDisplayId () const

virtual void	SetDisplayId (uint32 modelId)

uint32	GetNativeDisplayId () const

void	RestoreDisplayId ()

void	SetNativeDisplayId (uint32 modelId)

void	setTransForm (uint32 spellid)

uint32	getTransForm () const

void	_RegisterDynObject (DynamicObject *dynObj)

void	_UnregisterDynObject (DynamicObject *dynObj)

DynamicObject *	GetDynObject (uint32 spellId)

bool	RemoveDynObject (uint32 spellId)

void	RemoveAllDynObjects ()

GameObject *	GetGameObject (uint32 spellId) const

void	AddGameObject (GameObject *gameObj)

void	RemoveGameObject (GameObject *gameObj, bool del)

void	RemoveGameObject (uint32 spellid, bool del)

void	RemoveAllGameObjects ()

void	ModifyAuraState (AuraStateType flag, bool apply)

uint32	BuildAuraStateUpdateForTarget (Unit *target) const

bool	HasAuraState (AuraStateType flag, SpellInfo const spellProto=nullptr, Unit const Caster=nullptr) const

void	UnsummonAllTotems (bool onDeath=false)

Unit *	GetMagicHitRedirectTarget (Unit victim, SpellInfo const spellInfo)

Unit *	GetMeleeHitRedirectTarget (Unit victim, SpellInfo const spellInfo=nullptr)

int32	SpellBaseDamageBonusDone (SpellSchoolMask schoolMask)

int32	SpellBaseDamageBonusTaken (SpellSchoolMask schoolMask, bool isDoT=false)

float	SpellPctDamageModsDone (Unit victim, SpellInfo const spellProto, DamageEffectType damagetype)

uint32	SpellDamageBonusDone (Unit victim, SpellInfo const spellProto, uint32 pdamage, DamageEffectType damagetype, uint8 effIndex, float TotalMod=0.0f, uint32 stack=1)

uint32	SpellDamageBonusTaken (Unit caster, SpellInfo const spellProto, uint32 pdamage, DamageEffectType damagetype, uint32 stack=1)

int32	SpellBaseHealingBonusDone (SpellSchoolMask schoolMask)

int32	SpellBaseHealingBonusTaken (SpellSchoolMask schoolMask)

float	SpellPctHealingModsDone (Unit victim, SpellInfo const spellProto, DamageEffectType damagetype)

uint32	SpellHealingBonusDone (Unit victim, SpellInfo const spellProto, uint32 healamount, DamageEffectType damagetype, uint8 effIndex, float TotalMod=0.0f, uint32 stack=1)

uint32	SpellHealingBonusTaken (Unit caster, SpellInfo const spellProto, uint32 healamount, DamageEffectType damagetype, uint32 stack=1)

uint32	MeleeDamageBonusDone (Unit pVictim, uint32 damage, WeaponAttackType attType, SpellInfo const spellProto=nullptr, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL)

uint32	MeleeDamageBonusTaken (Unit attacker, uint32 pdamage, WeaponAttackType attType, SpellInfo const spellProto=nullptr, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL)

bool	isSpellBlocked (Unit victim, SpellInfo const spellProto, WeaponAttackType attackType=BASE_ATTACK)

bool	isBlockCritical ()

float	SpellDoneCritChance (Unit const , SpellInfo const spellProto, SpellSchoolMask schoolMask, WeaponAttackType attackType, bool skipEffectCheck) const

float	SpellTakenCritChance (Unit const caster, SpellInfo const spellProto, SpellSchoolMask schoolMask, float doneChance, WeaponAttackType attackType, bool skipEffectCheck) const

void	SetLastManaUse (uint32 spellCastTime)

bool	IsUnderLastManaUseEffect () const

void	SetContestedPvP (Player *attackedPlayer=nullptr, bool lookForNearContestedGuards=true)

uint32	GetCastingTimeForBonus (SpellInfo const *spellProto, DamageEffectType damagetype, uint32 CastingTime) const

float	CalculateDefaultCoefficient (SpellInfo const *spellInfo, DamageEffectType damagetype) const

void	CastDelayedSpellWithPeriodicAmount (Unit *caster, uint32 spellId, AuraType auraType, int32 addAmount, uint8 effectIndex=0)

void	ApplySpellImmune (uint32 spellId, uint32 op, uint32 type, bool apply, SpellImmuneBlockType blockType=SPELL_BLOCK_TYPE_ALL)

void	ApplySpellDispelImmunity (SpellInfo const *spellProto, DispelType type, bool apply)

virtual bool	IsImmunedToSpell (SpellInfo const spellInfo, Spell const spell=nullptr)

bool	IsImmunedToDamage (SpellSchoolMask meleeSchoolMask) const

bool	IsImmunedToDamage (SpellInfo const *spellInfo) const

bool	IsImmunedToDamage (Spell const *spell) const

bool	IsImmunedToSchool (SpellSchoolMask meleeSchoolMask) const

bool	IsImmunedToSchool (SpellInfo const *spellInfo) const

bool	IsImmunedToSchool (Spell const *spell) const

bool	IsImmunedToDamageOrSchool (SpellSchoolMask meleeSchoolMask) const

bool	IsImmunedToDamageOrSchool (SpellInfo const *spellInfo) const

virtual bool	IsImmunedToSpellEffect (SpellInfo const *spellInfo, uint32 index) const

void	UpdateSpeed (UnitMoveType mtype, bool forced)

float	GetSpeed (UnitMoveType mtype) const

float	GetSpeedRate (UnitMoveType mtype) const

void	SetSpeed (UnitMoveType mtype, float rate, bool forced=false)

void	SetSpeedRate (UnitMoveType mtype, float rate)

float	ApplyEffectModifiers (SpellInfo const *spellProto, uint8 effect_index, float value) const

int32	CalculateSpellDamage (Unit const target, SpellInfo const spellProto, uint8 effect_index, int32 const *basePoints=nullptr) const

int32	CalcSpellDuration (SpellInfo const *spellProto)

int32	ModSpellDuration (SpellInfo const spellProto, Unit const target, int32 duration, bool positive, uint32 effectMask)

void	ModSpellCastTime (SpellInfo const spellProto, int32 &castTime, Spell spell=nullptr)

float	CalculateLevelPenalty (SpellInfo const *spellProto) const

void	addFollower (FollowerReference *pRef)

void	removeFollower (FollowerReference *)

MotionMaster *	GetMotionMaster ()

const MotionMaster *	GetMotionMaster () const

virtual MovementGeneratorType	GetDefaultMovementType () const
	-------—End of Pet responses methods-------— More...

bool	IsStopped () const

void	StopMoving ()

void	StopMovingOnCurrentPos ()

virtual void	PauseMovement (uint32 timer=0, uint8 slot=0)

void	ResumeMovement (uint32 timer=0, uint8 slot=0)

void	AddUnitMovementFlag (uint32 f)

void	RemoveUnitMovementFlag (uint32 f)

bool	HasUnitMovementFlag (uint32 f) const

uint32	GetUnitMovementFlags () const

void	SetUnitMovementFlags (uint32 f)

void	AddExtraUnitMovementFlag (uint16 f)

void	RemoveExtraUnitMovementFlag (uint16 f)

uint16	HasExtraUnitMovementFlag (uint16 f) const

uint16	GetExtraUnitMovementFlags () const

void	SetExtraUnitMovementFlags (uint16 f)

void	SetControlled (bool apply, UnitState state)

void	DisableRotate (bool apply)

void	DisableSpline ()

uint8	GetComboPoints (Unit const *who=nullptr) const
	--------—Combo point system----------------— More...

uint8	GetComboPoints (ObjectGuid const &guid) const

Unit *	GetComboTarget () const

ObjectGuid const	GetComboTargetGUID () const

void	AddComboPoints (Unit *target, int8 count)

void	AddComboPoints (int8 count)

void	ClearComboPoints ()

void	SendComboPoints ()

void	AddComboPointHolder (Unit *unit)

void	RemoveComboPointHolder (Unit *unit)

void	ClearComboPointHolders ()

void	SendPetActionFeedback (uint8 msg)
	-------—Pet responses methods--------------— More...

void	SendPetTalk (uint32 pettalk)

void	SendPetAIReaction (ObjectGuid guid)

void	propagateSpeedChange ()
	-------—End of Pet responses methods-------— More...

void	ClearAllReactives ()

void	StartReactiveTimer (ReactiveType reactive)

void	UpdateReactives (uint32 p_time)

void	UpdateAuraForGroup (uint8 slot)

bool	CanProc ()

void	SetCantProc (bool apply)

void	AddPetAura (PetAura const *petSpell)

void	RemovePetAura (PetAura const *petSpell)

void	CastPetAura (PetAura const *aura)

bool	IsPetAura (Aura const *aura)

uint32	GetModelForForm (ShapeshiftForm form) const

uint32	GetModelForTotem (PlayerTotemType totemType)

void	SetRedirectThreat (ObjectGuid guid, uint32 pct)

void	ResetRedirectThreat ()

void	ModifyRedirectThreat (int32 amount)

uint32	GetRedirectThreatPercent ()

Unit *	GetRedirectThreatTarget () const

bool	CreateVehicleKit (uint32 id, uint32 creatureEntry)

void	RemoveVehicleKit ()

Vehicle *	GetVehicleKit () const

Vehicle *	GetVehicle () const

bool	IsOnVehicle (Unit const *vehicle) const

Unit *	GetVehicleBase () const

Creature *	GetVehicleCreatureBase () const

ObjectGuid	GetTransGUID () const override

TransportBase *	GetDirectTransport () const
	Returns the transport this unit is on directly (if on vehicle and transport, return vehicle) More...

bool	HandleSpellClick (Unit *clicker, int8 seatId=-1)

void	EnterVehicle (Unit *base, int8 seatId=-1)

void	EnterVehicleUnattackable (Unit *base, int8 seatId=-1)

void	ExitVehicle (Position const *exitPosition=nullptr)

void	ChangeSeat (int8 seatId, bool next=true)

void	_ExitVehicle (Position const *exitPosition=nullptr)

void	_EnterVehicle (Vehicle vehicle, int8 seatId, AuraApplication const aurApp=nullptr)

void	BuildMovementPacket (ByteBuffer *data) const

virtual bool	CanSwim () const
	this method checks the current flag of a unit More...

bool	IsLevitating () const

bool	IsWalking () const

bool	isMoving () const

bool	isTurning () const

bool	IsHovering () const

bool	isSwimming () const

virtual bool	CanFly () const =0

bool	IsFlying () const

bool	IsFalling () const

float	GetHoverHeight () const

virtual bool	CanEnterWater () const =0

void	RewardRage (uint32 damage, uint32 weaponSpeedHitFactor, bool attacker)

virtual float	GetFollowAngle () const

void	OutDebugInfo () const

virtual bool	isBeingLoaded () const

bool	IsDuringRemoveFromWorld () const

Pet *	ToPet ()

Totem *	ToTotem ()

TempSummon *	ToTempSummon ()

const TempSummon *	ToTempSummon () const

void	AddPointedBy (SafeUnitPointer *sup)

void	RemovePointedBy (SafeUnitPointer *sup)

void	ExecuteDelayedUnitRelocationEvent ()

void	ExecuteDelayedUnitAINotifyEvent ()

virtual bool	HasSpellCooldown (uint32) const

virtual bool	HasSpellItemCooldown (uint32, uint32) const

virtual void	AddSpellCooldown (uint32, uint32, uint32, bool needSendToClient=false, bool forceSendToSpectator=false)

bool	CanApplyResilience () const

void	PetSpellFail (SpellInfo const spellInfo, Unit target, uint32 result)

int32	CalculateAOEDamageReduction (int32 damage, uint32 schoolMask, Unit *caster) const

ObjectGuid	GetTarget () const

virtual void	SetTarget (ObjectGuid=ObjectGuid::Empty)=0

void	SetInstantCast (bool set)

bool	CanInstantCast () const

virtual void	Talk (std::string_view text, ChatMsg msgType, Language language, float textRange, WorldObject const *target)

virtual void	Say (std::string_view text, Language language, WorldObject const *target=nullptr)

virtual void	Yell (std::string_view text, Language language, WorldObject const *target=nullptr)

virtual void	TextEmote (std::string_view text, WorldObject const *target=nullptr, bool isBossEmote=false)

virtual void	Whisper (std::string_view text, Language language, Player *target, bool isBossWhisper=false)

virtual void	Talk (uint32 textId, ChatMsg msgType, float textRange, WorldObject const *target)

virtual void	Say (uint32 textId, WorldObject const *target=nullptr)

virtual void	Yell (uint32 textId, WorldObject const *target=nullptr)

virtual void	TextEmote (uint32 textId, WorldObject const *target=nullptr, bool isBossEmote=false)

virtual void	Whisper (uint32 textId, Player *target, bool isBossWhisper=false)

float	GetCollisionHeight () const override
	Return collision height sent to client. More...

float	GetCollisionWidth () const override
	this method gets the diameter of a Unit by DB if any value is defined, otherwise it gets the value by the DBC More...

float	GetCollisionRadius () const override
	this method gets the radius of a Unit by DB if any value is defined, otherwise it gets the value by the DBC More...

void	ProcessPositionDataChanged (PositionFullTerrainStatus const &data) override

virtual void	ProcessTerrainStatusUpdate ()

bool	CanRestoreMana (SpellInfo const *spellInfo) const

std::string	GetDebugInfo () const override

Public Member Functions inherited from WorldObject
	~WorldObject () override

virtual void	Update (uint32)

void	_Create (ObjectGuid::LowType guidlow, HighGuid guidhigh, uint32 phaseMask)

void	AddToWorld () override

void	RemoveFromWorld () override

void	GetNearPoint2D (WorldObject const searcher, float &x, float &y, float distance, float absAngle, Position const startPos=nullptr) const

void	GetNearPoint2D (float &x, float &y, float distance, float absAngle, Position const *startPos=nullptr) const

void	GetNearPoint (WorldObject const searcher, float &x, float &y, float &z, float searcher_size, float distance2d, float absAngle, float controlZ=0, Position const startPos=nullptr) const

void	GetVoidClosePoint (float &x, float &y, float &z, float size, float distance2d=0, float relAngle=0, float controlZ=0) const

bool	GetClosePoint (float &x, float &y, float &z, float size, float distance2d=0, float angle=0, WorldObject const *forWho=nullptr, bool force=false) const

void	MovePosition (Position &pos, float dist, float angle)

Position	GetNearPosition (float dist, float angle)

void	MovePositionToFirstCollision (Position &pos, float dist, float angle)

Position	GetFirstCollisionPosition (float startX, float startY, float startZ, float destX, float destY)

Position	GetFirstCollisionPosition (float destX, float destY, float destZ)

Position	GetFirstCollisionPosition (float dist, float angle)

Position	GetRandomNearPosition (float radius)

void	GetContactPoint (WorldObject const *obj, float &x, float &y, float &z, float distance2d=CONTACT_DISTANCE) const

void	GetChargeContactPoint (WorldObject const *obj, float &x, float &y, float &z, float distance2d=CONTACT_DISTANCE) const

float	GetObjectSize () const

virtual float	GetCombatReach () const

void	UpdateGroundPositionZ (float x, float y, float &z) const

void	UpdateAllowedPositionZ (float x, float y, float &z, float *groundZ=nullptr) const

void	GetRandomPoint (const Position &srcPos, float distance, float &rand_x, float &rand_y, float &rand_z) const

Position	GetRandomPoint (const Position &srcPos, float distance) const

uint32	GetInstanceId () const

virtual void	SetPhaseMask (uint32 newPhaseMask, bool update)

uint32	GetPhaseMask () const

bool	InSamePhase (WorldObject const *obj) const

bool	InSamePhase (uint32 phasemask) const

uint32	GetZoneId () const

uint32	GetAreaId () const

void	GetZoneAndAreaId (uint32 &zoneid, uint32 &areaid) const

bool	IsOutdoors () const

LiquidData const &	GetLiquidData () const

InstanceScript *	GetInstanceScript () const

std::string const &	GetName () const

void	SetName (std::string const &newname)

virtual std::string const &	GetNameForLocaleIdx (LocaleConstant) const

float	GetDistance (WorldObject const *obj) const

float	GetDistance (const Position &pos) const

float	GetDistance (float x, float y, float z) const

float	GetDistance2d (WorldObject const *obj) const

float	GetDistance2d (float x, float y) const

float	GetDistanceZ (WorldObject const *obj) const

bool	IsSelfOrInSameMap (WorldObject const *obj) const

bool	IsInMap (WorldObject const *obj) const

bool	IsWithinDist3d (float x, float y, float z, float dist) const

bool	IsWithinDist3d (const Position *pos, float dist) const

bool	IsWithinDist2d (float x, float y, float dist) const

bool	IsWithinDist2d (const Position *pos, float dist) const

bool	IsWithinDist (WorldObject const *obj, float dist2compare, bool is3D=true, bool useBoundingRadius=true) const

bool	IsWithinDistInMap (WorldObject const *obj, float dist2compare, bool is3D=true, bool useBoundingRadius=true) const

bool	IsWithinLOS (float x, float y, float z, VMAP::ModelIgnoreFlags ignoreFlags=VMAP::ModelIgnoreFlags::Nothing, LineOfSightChecks checks=LINEOFSIGHT_ALL_CHECKS) const

bool	IsWithinLOSInMap (WorldObject const *obj, VMAP::ModelIgnoreFlags ignoreFlags=VMAP::ModelIgnoreFlags::Nothing, LineOfSightChecks checks=LINEOFSIGHT_ALL_CHECKS, Optional< float > collisionHeight={ }) const

Position	GetHitSpherePointFor (Position const &dest, Optional< float > collisionHeight={ }) const

void	GetHitSpherePointFor (Position const &dest, float &x, float &y, float &z, Optional< float > collisionHeight={ }) const

bool	GetDistanceOrder (WorldObject const obj1, WorldObject const obj2, bool is3D=true) const

bool	IsInRange (WorldObject const *obj, float minRange, float maxRange, bool is3D=true) const

bool	IsInRange2d (float x, float y, float minRange, float maxRange) const

bool	IsInRange3d (float x, float y, float z, float minRange, float maxRange) const

bool	isInFront (WorldObject const *target, float arc=M_PI) const

bool	isInBack (WorldObject const *target, float arc=M_PI) const

bool	IsInBetween (WorldObject const obj1, WorldObject const obj2, float size=0) const

virtual void	CleanupsBeforeDelete (bool finalCleanup=true)

virtual void	SendMessageToSet (WorldPacket const *data, bool self) const

virtual void	SendMessageToSetInRange (WorldPacket const data, float dist, bool, bool includeMargin=false, Player const skipped_rcvr=nullptr) const

virtual void	SendMessageToSet (WorldPacket const data, Player const skipped_rcvr) const

virtual uint8	getLevelForTarget (WorldObject const *) const

void	PlayDistanceSound (uint32 sound_id, Player *target=nullptr)

void	PlayDirectSound (uint32 sound_id, Player *target=nullptr)

void	PlayDirectMusic (uint32 music_id, Player *target=nullptr)

void	SendObjectDeSpawnAnim (ObjectGuid guid)

virtual void	SaveRespawnTime ()

void	AddObjectToRemoveList ()

float	GetGridActivationRange () const

float	GetVisibilityRange () const

virtual float	GetSightRange (WorldObject const *target=nullptr) const

bool	CanSeeOrDetect (WorldObject const *obj, bool ignoreStealth=false, bool distanceCheck=false, bool checkAlert=false) const

void	SendPlayMusic (uint32 Music, bool OnlySelf)

virtual void	SetMap (Map *map)

virtual void	ResetMap ()

Map *	GetMap () const

Map *	FindMap () const

void	SetZoneScript ()

void	ClearZoneScript ()

ZoneScript *	GetZoneScript () const

TempSummon *	SummonCreature (uint32 id, const Position &pos, TempSummonType spwtype=TEMPSUMMON_MANUAL_DESPAWN, uint32 despwtime=0, uint32 vehId=0, SummonPropertiesEntry const *properties=nullptr) const

TempSummon *	SummonCreature (uint32 id, float x, float y, float z, float ang=0, TempSummonType spwtype=TEMPSUMMON_MANUAL_DESPAWN, uint32 despwtime=0, SummonPropertiesEntry const *properties=nullptr)

GameObject *	SummonGameObject (uint32 entry, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime, bool checkTransport=true, GOSummonType summonType=GO_SUMMON_TIMED_OR_CORPSE_DESPAWN)

Creature *	SummonTrigger (float x, float y, float z, float ang, uint32 dur, bool setLevel=false, CreatureAI (GetAI)(Creature *)=nullptr)

void	SummonCreatureGroup (uint8 group, std::list< TempSummon * > *list=nullptr)

Creature *	FindNearestCreature (uint32 entry, float range, bool alive=true) const

GameObject *	FindNearestGameObject (uint32 entry, float range, bool onlySpawned=false) const

GameObject *	FindNearestGameObjectOfType (GameobjectTypes type, float range) const

Player *	SelectNearestPlayer (float distance=0) const

void	GetGameObjectListWithEntryInGrid (std::list< GameObject * > &lList, uint32 uiEntry, float fMaxSearchRange) const

void	GetCreatureListWithEntryInGrid (std::list< Creature * > &lList, uint32 uiEntry, float fMaxSearchRange) const

void	GetDeadCreatureListInGrid (std::list< Creature * > &lList, float maxSearchRange, bool alive=false) const

void	DestroyForNearbyPlayers ()

virtual void	UpdateObjectVisibility (bool forced=true, bool fromUpdate=false)

void	BuildUpdate (UpdateDataMapType &data_map, UpdatePlayerSet &player_set) override

void	GetCreaturesWithEntryInRange (std::list< Creature * > &creatureList, float radius, uint32 entry)

void	SetPositionDataUpdate ()

void	UpdatePositionData ()

void	AddToObjectUpdate () override

void	RemoveFromObjectUpdate () override

void	AddToNotify (uint16 f)

void	RemoveFromNotify (uint16 f)

bool	isNeedNotify (uint16 f) const

uint16	GetNotifyFlags () const

bool	NotifyExecuted (uint16 f) const

void	SetNotified (uint16 f)

void	ResetAllNotifies ()

bool	isActiveObject () const

void	setActive (bool isActiveObject)

bool	IsFarVisible () const

bool	IsVisibilityOverridden () const

void	SetVisibilityDistanceOverride (VisibilityDistanceType type)

void	SetWorldObject (bool apply)

bool	IsPermanentWorldObject () const

bool	IsWorldObject () const

bool	IsInWintergrasp () const

Transport *	GetTransport () const

float	GetTransOffsetX () const

float	GetTransOffsetY () const

float	GetTransOffsetZ () const

float	GetTransOffsetO () const

uint32	GetTransTime () const

int8	GetTransSeat () const

virtual ObjectGuid	GetTransGUID () const

void	SetTransport (Transport *t)

virtual float	GetStationaryX () const

virtual float	GetStationaryY () const

virtual float	GetStationaryZ () const

virtual float	GetStationaryO () const

float	GetMapWaterOrGroundLevel (float x, float y, float z, float *ground=nullptr) const

float	GetMapHeight (float x, float y, float z, bool vmap=true, float distanceToSearch=50.0f) const

float	GetFloorZ () const

float	GetMinHeightInWater () const
	Get the minimum height of a object that should be in water to start floating/swim. More...

virtual float	GetCollisionHeight () const

virtual float	GetCollisionWidth () const

virtual float	GetCollisionRadius () const

void	AddAllowedLooter (ObjectGuid guid)

void	ResetAllowedLooters ()

void	SetAllowedLooters (GuidUnorderedSet const looters)

bool	HasAllowedLooter (ObjectGuid guid) const

GuidUnorderedSet const &	GetAllowedLooters () const

std::string	GetDebugInfo () const override

Public Member Functions inherited from Object
virtual	~Object ()

bool	IsInWorld () const

virtual void	AddToWorld ()

virtual void	RemoveFromWorld ()

ObjectGuid	GetGUID () const

PackedGuid const &	GetPackGUID () const

uint32	GetEntry () const

void	SetEntry (uint32 entry)

float	GetObjectScale () const

virtual void	SetObjectScale (float scale)

virtual uint32	GetDynamicFlags () const

bool	HasDynamicFlag (uint32 flag) const

virtual void	SetDynamicFlag (uint32 flag)

virtual void	RemoveDynamicFlag (uint32 flag)

virtual void	ReplaceAllDynamicFlags (uint32 flag)

TypeID	GetTypeId () const

bool	isType (uint16 mask) const

virtual void	BuildCreateUpdateBlockForPlayer (UpdateData data, Player target) const

void	SendUpdateToPlayer (Player *player)

void	BuildValuesUpdateBlockForPlayer (UpdateData data, Player target) const

void	BuildOutOfRangeUpdateBlock (UpdateData *data) const

void	BuildMovementUpdateBlock (UpdateData *data, uint32 flags=0) const

virtual void	DestroyForPlayer (Player *target, bool onDeath=false) const

int32	GetInt32Value (uint16 index) const

uint32	GetUInt32Value (uint16 index) const

uint64	GetUInt64Value (uint16 index) const

float	GetFloatValue (uint16 index) const

uint8	GetByteValue (uint16 index, uint8 offset) const

uint16	GetUInt16Value (uint16 index, uint8 offset) const

ObjectGuid	GetGuidValue (uint16 index) const

void	SetInt32Value (uint16 index, int32 value)

void	SetUInt32Value (uint16 index, uint32 value)

void	UpdateUInt32Value (uint16 index, uint32 value)

void	SetUInt64Value (uint16 index, uint64 value)

void	SetFloatValue (uint16 index, float value)

void	SetByteValue (uint16 index, uint8 offset, uint8 value)

void	SetUInt16Value (uint16 index, uint8 offset, uint16 value)

void	SetInt16Value (uint16 index, uint8 offset, int16 value)

void	SetGuidValue (uint16 index, ObjectGuid value)

void	SetStatFloatValue (uint16 index, float value)

void	SetStatInt32Value (uint16 index, int32 value)

bool	AddGuidValue (uint16 index, ObjectGuid value)

bool	RemoveGuidValue (uint16 index, ObjectGuid value)

void	ApplyModUInt32Value (uint16 index, int32 val, bool apply)

void	ApplyModInt32Value (uint16 index, int32 val, bool apply)

void	ApplyModUInt64Value (uint16 index, int32 val, bool apply)

void	ApplyModPositiveFloatValue (uint16 index, float val, bool apply)

void	ApplyModSignedFloatValue (uint16 index, float val, bool apply)

void	ApplyPercentModFloatValue (uint16 index, float val, bool apply)

void	SetFlag (uint16 index, uint32 newFlag)

void	RemoveFlag (uint16 index, uint32 oldFlag)

void	ToggleFlag (uint16 index, uint32 flag)

bool	HasFlag (uint16 index, uint32 flag) const

void	ApplyModFlag (uint16 index, uint32 flag, bool apply)

void	SetByteFlag (uint16 index, uint8 offset, uint8 newFlag)

void	RemoveByteFlag (uint16 index, uint8 offset, uint8 newFlag)

bool	HasByteFlag (uint16 index, uint8 offset, uint8 flag) const

void	SetFlag64 (uint16 index, uint64 newFlag)

void	RemoveFlag64 (uint16 index, uint64 oldFlag)

void	ToggleFlag64 (uint16 index, uint64 flag)

bool	HasFlag64 (uint16 index, uint64 flag) const

void	ApplyModFlag64 (uint16 index, uint64 flag, bool apply)

void	ClearUpdateMask (bool remove)

uint16	GetValuesCount () const

virtual bool	hasQuest (uint32) const

virtual bool	hasInvolvedQuest (uint32) const

virtual void	BuildUpdate (UpdateDataMapType &, UpdatePlayerSet &)

void	BuildFieldsUpdate (Player *, UpdateDataMapType &) const

void	SetFieldNotifyFlag (uint16 flag)

void	RemoveFieldNotifyFlag (uint16 flag)

void	ForceValuesUpdateAtIndex (uint32)

bool	IsPlayer () const

Player *	ToPlayer ()

Player const *	ToPlayer () const

Creature *	ToCreature ()

Creature const *	ToCreature () const

Unit *	ToUnit ()

Unit const *	ToUnit () const

GameObject *	ToGameObject ()

GameObject const *	ToGameObject () const

Corpse *	ToCorpse ()

Corpse const *	ToCorpse () const

DynamicObject *	ToDynObject ()

DynamicObject const *	ToDynObject () const

virtual std::string	GetDebugInfo () const

Public Member Functions inherited from WorldLocation
	WorldLocation (uint32 _mapId=MAPID_INVALID, float x=0.f, float y=0.f, float z=0.f, float o=0.f)

	WorldLocation (uint32 mapId, Position const &position)

void	WorldRelocate (const WorldLocation &loc)

void	WorldRelocate (uint32 mapId=MAPID_INVALID, float x=0.f, float y=0.f, float z=0.f, float o=0.f)

void	SetMapId (uint32 mapId)

uint32	GetMapId () const

void	GetWorldLocation (uint32 &mapId, float &x, float &y) const

void	GetWorldLocation (uint32 &mapId, float &x, float &y, float &z) const

void	GetWorldLocation (uint32 &mapId, float &x, float &y, float &z, float &o) const

void	GetWorldLocation (WorldLocation *location) const

WorldLocation	GetWorldLocation () const

std::string	GetDebugInfo () const

Public Member Functions inherited from Position
	Position (float x=0, float y=0, float z=0, float o=0)

	Position (Position const &loc)

	Position (Position &&)=default

Position &	operator= (const Position &)=default

Position &	operator= (Position &&)=default

bool	operator== (Position const &a) const

bool	operator!= (Position const &a)

	operator G3D::Vector3 () const

void	Relocate (float x, float y)

void	Relocate (float x, float y, float z)

void	Relocate (float x, float y, float z, float orientation)

void	Relocate (const Position &pos)

void	Relocate (const Position *pos)

void	RelocatePolarOffset (float angle, float dist, float z=0.0f)

void	RelocateOffset (const Position &offset)

void	SetOrientation (float orientation)

float	GetPositionX () const

float	GetPositionY () const

float	GetPositionZ () const

float	GetOrientation () const

void	GetPosition (float &x, float &y) const

void	GetPosition (float &x, float &y, float &z) const

void	GetPosition (float &x, float &y, float &z, float &o) const

Position	GetPosition () const

Position::PositionXYZStreamer	PositionXYZStream ()

Position::PositionXYZOStreamer	PositionXYZOStream ()

bool	IsPositionValid () const

float	GetExactDist2dSq (const float x, const float y) const

float	GetExactDist2dSq (Position const &pos) const

float	GetExactDist2dSq (Position const *pos) const

float	GetExactDist2d (const float x, const float y) const

float	GetExactDist2d (Position const &pos) const

float	GetExactDist2d (Position const *pos) const

float	GetExactDistSq (float x, float y, float z) const

float	GetExactDistSq (Position const &pos) const

float	GetExactDistSq (Position const *pos) const

float	GetExactDist (float x, float y, float z) const

float	GetExactDist (Position const &pos) const

float	GetExactDist (Position const *pos) const

void	GetPositionOffsetTo (const Position &endPos, Position &retOffset) const

Position	GetPositionWithOffset (Position const &offset) const

float	GetAngle (const Position *pos) const

float	GetAngle (float x, float y) const

float	GetAbsoluteAngle (float x, float y) const

float	GetAbsoluteAngle (Position const &pos) const

float	GetAbsoluteAngle (Position const *pos) const

float	GetRelativeAngle (const Position *pos) const

float	GetRelativeAngle (float x, float y) const

float	ToAbsoluteAngle (float relAngle) const

void	GetSinCos (float x, float y, float &vsin, float &vcos) const

bool	IsInDist2d (float x, float y, float dist) const

bool	IsInDist2d (const Position *pos, float dist) const

bool	IsInDist (float x, float y, float z, float dist) const

bool	IsInDist (const Position *pos, float dist) const

bool	IsWithinBox (const Position &center, float xradius, float yradius, float zradius) const

bool	HasInArc (float arcangle, const Position *pos, float targetRadius=0.0f) const

bool	HasInLine (Position const *pos, float width) const

std::string	ToString () const

Static Public Member Functions
static float	GetEffectiveResistChance (Unit const owner, SpellSchoolMask schoolMask, Unit const victim)

static void	DealDamageMods (Unit const victim, uint32 &damage, uint32 absorb)

static uint32	DealDamage (Unit attacker, Unit victim, uint32 damage, CleanDamage const cleanDamage=nullptr, DamageEffectType damagetype=DIRECT_DAMAGE, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL, SpellInfo const spellProto=nullptr, bool durabilityLoss=true, bool allowGM=false, Spell const *spell=nullptr)

static void	Kill (Unit killer, Unit victim, bool durabilityLoss=true, WeaponAttackType attackType=BASE_ATTACK, SpellInfo const spellProto=nullptr, Spell const spell=nullptr)

static int32	DealHeal (Unit healer, Unit victim, uint32 addhealth)

static void	ProcDamageAndSpell (Unit actor, Unit victim, uint32 procAttacker, uint32 procVictim, uint32 procEx, uint32 amount, WeaponAttackType attType=BASE_ATTACK, SpellInfo const procSpellInfo=nullptr, SpellInfo const procAura=nullptr, int8 procAuraEffectIndex=-1, Spell const procSpell=nullptr, DamageInfo damageInfo=nullptr, HealInfo *healInfo=nullptr, uint32 procPhase=2)

static void	ApplyResilience (Unit const victim, float crit, int32 *damage, bool isCrit, CombatRating type)

static uint32	SpellCriticalDamageBonus (Unit const caster, SpellInfo const spellProto, uint32 damage, Unit const *victim)

static uint32	SpellCriticalHealingBonus (Unit const caster, SpellInfo const spellProto, uint32 damage, Unit const *victim)

static bool	IsDamageReducedByArmor (SpellSchoolMask damageSchoolMask, SpellInfo const *spellInfo=nullptr, uint8 effIndex=MAX_SPELL_EFFECTS)

static uint32	CalcArmorReducedDamage (Unit const attacker, Unit const victim, const uint32 damage, SpellInfo const *spellInfo, uint8 attackerLevel=0, WeaponAttackType attackType=MAX_ATTACK)

static void	CalcAbsorbResist (DamageInfo &dmgInfo, bool Splited=false)

static void	CalcHealAbsorb (HealInfo &healInfo)

static void	HandleSafeUnitPointersOnDelete (Unit *thisUnit)

Static Public Member Functions inherited from Object
static ObjectGuid	GetGUID (Object const *o)

Static Public Member Functions inherited from Position
static float	NormalizeOrientation (float o)

Public Attributes
uint32	m_extraAttacks

bool	m_canDualWield

ControlSet	m_Controlled

SafeUnitPointer	m_movedByPlayer

ObjectGuid	m_SummonSlot [MAX_SUMMON_SLOT]

ObjectGuid	m_ObjectSlot [MAX_GAMEOBJECT_SLOT]

float	m_modMeleeHitChance

float	m_modRangedHitChance

float	m_modSpellHitChance

int32	m_baseSpellCritChance

float	m_threatModifier [MAX_SPELL_SCHOOL]

float	m_modAttackSpeedPct [3]

EventProcessor	m_Events

SpellImmuneList	m_spellImmune [MAX_SPELL_IMMUNITY]

uint32	m_lastSanctuaryTime

PetAuraSet	m_petAuras

bool	IsAIEnabled

bool	NeedChangeAI

bool	m_ControlledByPlayer

bool	m_CreatedByPlayer

std::set< SafeUnitPointer * >	SafeUnitPointerSet

Position	m_last_notify_position

uint32	m_last_notify_mstime

uint16	m_delayed_unit_relocation_timer

uint16	m_delayed_unit_ai_notify_timer

bool	bRequestForcedVisibilityUpdate

Movement::MoveSpline *	movespline

Public Attributes inherited from WorldObject
FlaggedValuesArray32< int32, uint32, StealthType, TOTAL_STEALTH_TYPES >	m_stealth

FlaggedValuesArray32< int32, uint32, StealthType, TOTAL_STEALTH_TYPES >	m_stealthDetect

FlaggedValuesArray32< int32, uint32, InvisibilityType, TOTAL_INVISIBILITY_TYPES >	m_invisibility

FlaggedValuesArray32< int32, uint32, InvisibilityType, TOTAL_INVISIBILITY_TYPES >	m_invisibilityDetect

FlaggedValuesArray32< int32, uint32, ServerSideVisibilityType, TOTAL_SERVERSIDE_VISIBILITY_TYPES >	m_serverSideVisibility

FlaggedValuesArray32< int32, uint32, ServerSideVisibilityType, TOTAL_SERVERSIDE_VISIBILITY_TYPES >	m_serverSideVisibilityDetect

uint32	LastUsedScriptID

MovementInfo	m_movementInfo

ElunaEventProcessor *	elunaEvents

Public Attributes inherited from Object
DataMap	CustomData

Public Attributes inherited from WorldLocation
uint32	m_mapId

Public Attributes inherited from Position
float	m_positionX = 0

float	m_positionY = 0

float	m_positionZ = 0

float	m_orientation = 0

Protected Types
typedef std::list< DynamicObject * >	DynObjectList

typedef GuidList	GameObjectList

typedef std::map< ObjectGuid, float >	CharmThreatMap

Protected Member Functions
	Unit (bool isWorldObject)

void	BuildValuesUpdate (uint8 updatetype, ByteBuffer data, Player target) const override

void	_UpdateSpells (uint32 time)

void	_DeleteRemovedAuras ()

void	_UpdateAutoRepeatSpell ()

bool	IsAlwaysVisibleFor (WorldObject const *seer) const override

bool	IsAlwaysDetectableFor (WorldObject const *seer) const override

void	SetFeared (bool apply)

void	SetConfused (bool apply)

void	SetStunned (bool apply)

void	SetRooted (bool apply, bool isStun=false)

Protected Member Functions inherited from WorldObject
	WorldObject (bool isWorldObject)

virtual void	ProcessPositionDataChanged (PositionFullTerrainStatus const &data)

void	SetLocationMapId (uint32 _mapId)

void	SetLocationInstanceId (uint32 _instanceId)

virtual bool	IsNeverVisible () const

virtual bool	IsAlwaysVisibleFor (WorldObject const *) const

virtual bool	IsInvisibleDueToDespawn () const

virtual bool	IsAlwaysDetectableFor (WorldObject const *) const

Protected Member Functions inherited from Object
	Object ()

void	_InitValues ()

void	_Create (ObjectGuid::LowType guidlow, uint32 entry, HighGuid guidhigh)

std::string	_ConcatFields (uint16 startIndex, uint16 size) const

bool	_LoadIntoDataField (std::string const &data, uint32 startOffset, uint32 count)

uint32	GetUpdateFieldData (Player const target, uint32 &flags) const

void	BuildMovementUpdate (ByteBuffer *data, uint16 flags) const

virtual void	BuildValuesUpdate (uint8 updatetype, ByteBuffer data, Player target) const

virtual void	AddToObjectUpdate ()=0

virtual void	RemoveFromObjectUpdate ()=0

void	AddToObjectUpdateIfNeeded ()

Protected Attributes
UnitAI *	i_AI

UnitAI *	i_disabledAI

uint8	m_realRace

uint8	m_race

bool	m_AutoRepeatFirstCast

int32	m_attackTimer [MAX_ATTACK]

float	m_createStats [MAX_STATS]

AttackerSet	m_attackers

Unit *	m_attacking

DeathState	m_deathState

int32	m_procDeep

DynObjectList	m_dynObj

GameObjectList	m_gameObj

uint32	m_transform

Spell *	m_currentSpells [CURRENT_MAX_SPELL]

AuraMap	m_ownedAuras

AuraApplicationMap	m_appliedAuras

AuraList	m_removedAuras

AuraMap::iterator	m_auraUpdateIterator

uint32	m_removedAurasCount

AuraEffectList	m_modAuras [TOTAL_AURAS]

AuraList	m_scAuras

AuraApplicationList	m_interruptableAuras

AuraStateAurasMap	m_auraStateAuras

uint32	m_interruptMask

float	m_auraModifiersGroup [UNIT_MOD_END][MODIFIER_TYPE_END]

float	m_weaponDamage [MAX_ATTACK][MAX_WEAPON_DAMAGE_RANGE][MAX_ITEM_PROTO_DAMAGES]

bool	m_canModifyStats

VisibleAuraMap	m_visibleAuras

float	m_speed_rate [MAX_MOVE_TYPE]

CharmInfo *	m_charmInfo

SharedVisionList	m_sharedVision

MotionMaster *	i_motionMaster

uint32	m_reactiveTimer [MAX_REACTIVE]

int32	m_regenTimer

ThreatMgr	m_ThreatMgr

CharmThreatMap	_charmThreatInfo

Vehicle *	m_vehicle

Vehicle *	m_vehicleKit

uint32	m_unitTypeMask

LiquidTypeEntry const *	_lastLiquid

bool	m_applyResilience

bool	_instantCast

uint32	m_rootTimes

Protected Attributes inherited from WorldObject
std::string	m_name

bool	m_isActive

bool	m_isFarVisible

Optional< float >	m_visibilityDistanceOverride

const bool	m_isWorldObject

ZoneScript *	m_zoneScript

uint32	_zoneId

uint32	_areaId

float	_floorZ

bool	_outdoors

LiquidData	_liquidData

bool	_updatePositionData

Transport *	m_transport

Protected Attributes inherited from Object
uint16	m_objectType

TypeID	m_objectTypeId

uint16	m_updateFlag

union {
int32 * m_int32Values

uint32 * m_uint32Values

float * m_floatValues

};

UpdateMask	_changesMask

uint16	m_valuesCount

uint16	_fieldNotifyFlags

bool	m_objectUpdated

Private Member Functions
bool	IsTriggeredAtSpellProcEvent (Unit victim, Aura aura, WeaponAttackType attType, bool isVictim, bool active, SpellProcEventEntry const *&spellProcEvent, ProcEventInfo const &eventInfo)

bool	HandleDummyAuraProc (Unit victim, uint32 damage, AuraEffect triggeredByAura, SpellInfo const procSpell, uint32 procFlag, uint32 procEx, uint32 cooldown, Spell const spellProc=nullptr)

bool	HandleAuraProc (Unit victim, uint32 damage, Aura triggeredByAura, SpellInfo const procSpell, uint32 procFlag, uint32 procEx, uint32 cooldown, bool handled)

bool	HandleProcTriggerSpell (Unit victim, uint32 damage, AuraEffect triggeredByAura, SpellInfo const *procSpell, uint32 procFlag, uint32 procEx, uint32 cooldown, uint32 procPhase, ProcEventInfo &eventInfo)

bool	HandleOverrideClassScriptAuraProc (Unit victim, uint32 damage, AuraEffect triggeredByAura, SpellInfo const *procSpell, uint32 cooldown)

bool	HandleAuraRaidProcFromChargeWithValue (AuraEffect *triggeredByAura)

bool	HandleAuraRaidProcFromCharge (AuraEffect *triggeredByAura)

void	UpdateSplineMovement (uint32 t_diff)

void	UpdateSplinePosition ()

float	GetCombatRatingReduction (CombatRating cr) const

uint32	GetCombatRatingDamageReduction (CombatRating cr, float rate, float cap, uint32 damage) const

float	processDummyAuras (float TakenTotalMod) const

Private Attributes
uint32	m_state

uint32	m_CombatTimer

uint32	m_lastManaUse

Diminishing	m_Diminishing

HostileRefMgr	m_HostileRefMgr

FollowerRefMgr	m_FollowingRefMgr

Unit *	m_comboTarget

int8	m_comboPoints

std::unordered_set< Unit * >	m_ComboPointHolders

RedirectThreatInfo	_redirectThreatInfo

bool	m_cleanupDone

bool	m_duringRemoveFromWorld

uint32	_oldFactionId
	faction before charm More...

bool	_isWalkingBeforeCharm
	Are we walking before we were charmed? More...

uint32	_lastExtraAttackSpell

std::unordered_map< ObjectGuid, uint32 >	extraAttacksTargets

ObjectGuid	_lastDamagedTargetGuid

Detailed Description

Definition at line 1289 of file Unit.h.

Member Typedef Documentation

◆ AttackerSet

typedef std::unordered_set<Unit*> Unit::AttackerSet

Definition at line 1292 of file Unit.h.

◆ AuraApplicationList

typedef std::list<AuraApplication*> Unit::AuraApplicationList

Definition at line 1308 of file Unit.h.

◆ AuraApplicationMap

typedef std::multimap<uint32, AuraApplication*> Unit::AuraApplicationMap

Definition at line 1299 of file Unit.h.

◆ AuraApplicationMapBounds

typedef std::pair<AuraApplicationMap::const_iterator, AuraApplicationMap::const_iterator> Unit::AuraApplicationMapBounds

Definition at line 1300 of file Unit.h.

◆ AuraApplicationMapBoundsNonConst

typedef std::pair<AuraApplicationMap::iterator, AuraApplicationMap::iterator> Unit::AuraApplicationMapBoundsNonConst

Definition at line 1301 of file Unit.h.

◆ AuraEffectList

typedef std::list<AuraEffect*> Unit::AuraEffectList

Definition at line 1306 of file Unit.h.

◆ AuraList

typedef std::list<Aura*> Unit::AuraList

Definition at line 1307 of file Unit.h.

◆ AuraMap

typedef std::multimap<uint32, Aura*> Unit::AuraMap

Definition at line 1295 of file Unit.h.

◆ AuraMapBounds

typedef std::pair<AuraMap::const_iterator, AuraMap::const_iterator> Unit::AuraMapBounds

Definition at line 1296 of file Unit.h.

◆ AuraMapBoundsNonConst

typedef std::pair<AuraMap::iterator, AuraMap::iterator> Unit::AuraMapBoundsNonConst

Definition at line 1297 of file Unit.h.

◆ AuraStateAurasMap

typedef std::multimap<AuraStateType, AuraApplication*> Unit::AuraStateAurasMap

Definition at line 1303 of file Unit.h.

◆ AuraStateAurasMapBounds

typedef std::pair<AuraStateAurasMap::const_iterator, AuraStateAurasMap::const_iterator> Unit::AuraStateAurasMapBounds

Definition at line 1304 of file Unit.h.

◆ CharmThreatMap

typedef std::map<ObjectGuid, float> Unit::CharmThreatMap

protected

Definition at line 2524 of file Unit.h.

◆ ComboPointHolderSet

typedef GuidUnorderedSet Unit::ComboPointHolderSet

Definition at line 1310 of file Unit.h.

◆ ControlSet

typedef std::set<Unit*> Unit::ControlSet

Definition at line 1293 of file Unit.h.

◆ Diminishing

typedef std::list<DiminishingReturn> Unit::Diminishing

Definition at line 1309 of file Unit.h.

◆ DynObjectList

typedef std::list<DynamicObject*> Unit::DynObjectList

protected

Definition at line 2487 of file Unit.h.

◆ GameObjectList

typedef GuidList Unit::GameObjectList

protected

Definition at line 2490 of file Unit.h.

◆ PetAuraSet

typedef std::set<PetAura const*> Unit::PetAuraSet

Definition at line 2328 of file Unit.h.

◆ VisibleAuraMap

typedef std::map<uint8, AuraApplication*> Unit::VisibleAuraMap

Definition at line 1312 of file Unit.h.

Constructor & Destructor Documentation

◆ ~Unit()

Unit::~Unit ( )

override

Definition at line 358 of file Unit.cpp.

{
    // set current spells as deletable
    for (uint8 i = 0; i < CURRENT_MAX_SPELL; ++i)
        if (m_currentSpells[i])
        {
            m_currentSpells[i]->SetReferencedFromCurrent(false);
            m_currentSpells[i] = nullptr;
        }
 
    _DeleteRemovedAuras();
 
    delete i_motionMaster;
    delete m_charmInfo;
    delete movespline;
 
    ASSERT(!m_duringRemoveFromWorld);
    ASSERT(!m_attacking);
    ASSERT(m_attackers.empty());
 
    // pussywizard: clear m_sharedVision along with back references
    if (!m_sharedVision.empty())
    {
        do
        {
            Player* p = *(m_sharedVision.begin());
            p->m_isInSharedVisionOf.erase(this);
            m_sharedVision.remove(p);
        } while (!m_sharedVision.empty());
    }
 
    ASSERT(m_Controlled.empty());
    ASSERT(m_appliedAuras.empty());
    ASSERT(m_ownedAuras.empty());
    ASSERT(m_removedAuras.empty());
    ASSERT(m_gameObj.empty());
    ASSERT(m_dynObj.empty());
 
    if (m_movedByPlayer && m_movedByPlayer != this)
        LOG_INFO("misc", "Unit::~Unit (A1)");
 
    HandleSafeUnitPointersOnDelete(this);
}

◆ Unit()

Unit::Unit ( bool isWorldObject )

explicitprotected

Definition at line 205 of file Unit.cpp.

                             : WorldObject(isWorldObject),
    m_movedByPlayer(nullptr),
    m_lastSanctuaryTime(0),
    IsAIEnabled(false),
    NeedChangeAI(false),
    m_ControlledByPlayer(false),
    m_CreatedByPlayer(false),
    movespline(new Movement::MoveSpline()),
    i_AI(nullptr),
    i_disabledAI(nullptr),
    m_realRace(0),
    m_race(0),
    m_AutoRepeatFirstCast(false),
    m_procDeep(0),
    m_removedAurasCount(0),
    i_motionMaster(new MotionMaster(this)),
    m_regenTimer(0),
    m_ThreatMgr(this),
    m_vehicle(nullptr),
    m_vehicleKit(nullptr),
    m_unitTypeMask(UNIT_MASK_NONE),
    m_HostileRefMgr(this),
    m_comboTarget(nullptr),
    m_comboPoints(0)
{
#ifdef _MSC_VER
#pragma warning(default:4355)
#endif
    m_objectType |= TYPEMASK_UNIT;
    m_objectTypeId = TYPEID_UNIT;
 
    m_updateFlag = (UPDATEFLAG_LIVING | UPDATEFLAG_STATIONARY_POSITION);
 
    m_attackTimer[BASE_ATTACK] = 0;
    m_attackTimer[OFF_ATTACK] = 0;
    m_attackTimer[RANGED_ATTACK] = 0;
    m_modAttackSpeedPct[BASE_ATTACK] = 1.0f;
    m_modAttackSpeedPct[OFF_ATTACK] = 1.0f;
    m_modAttackSpeedPct[RANGED_ATTACK] = 1.0f;
 
    m_canDualWield = false;
 
    m_rootTimes = 0;
 
    m_state = 0;
    m_deathState = ALIVE;
 
    for (uint8 i = 0; i < CURRENT_MAX_SPELL; ++i)
        m_currentSpells[i] = nullptr;
 
    for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
        m_SummonSlot[i].Clear();
 
    for (uint8 i = 0; i < MAX_GAMEOBJECT_SLOT; ++i)
        m_ObjectSlot[i].Clear();
 
    m_auraUpdateIterator = m_ownedAuras.end();
 
    m_interruptMask = 0;
    m_transform = 0;
    m_canModifyStats = false;
 
    for (uint8 i = 0; i < MAX_SPELL_IMMUNITY; ++i)
        m_spellImmune[i].clear();
 
    for (uint8 i = 0; i < UNIT_MOD_END; ++i)
    {
        m_auraModifiersGroup[i][BASE_VALUE] = 0.0f;
        m_auraModifiersGroup[i][BASE_PCT] = 1.0f;
        m_auraModifiersGroup[i][TOTAL_VALUE] = 0.0f;
        m_auraModifiersGroup[i][TOTAL_PCT] = 1.0f;
    }
    // implement 50% base damage from offhand
    m_auraModifiersGroup[UNIT_MOD_DAMAGE_OFFHAND][TOTAL_PCT] = 0.5f;
 
    for (uint8 i = 0; i < MAX_ATTACK; ++i)
    {
        m_weaponDamage[i][MINDAMAGE][0] = BASE_MINDAMAGE;
        m_weaponDamage[i][MAXDAMAGE][0] = BASE_MAXDAMAGE;
 
        m_weaponDamage[i][MINDAMAGE][1] = 0.f;
        m_weaponDamage[i][MAXDAMAGE][1] = 0.f;
    }
 
    for (uint8 i = 0; i < MAX_STATS; ++i)
        m_createStats[i] = 0.0f;
 
    m_attacking = nullptr;
    m_modMeleeHitChance = 0.0f;
    m_modRangedHitChance = 0.0f;
    m_modSpellHitChance = 0.0f;
    m_baseSpellCritChance = 5;
 
    m_CombatTimer = 0;
    m_lastManaUse = 0;
 
    for (uint8 i = 0; i < MAX_SPELL_SCHOOL; ++i)
        m_threatModifier[i] = 1.0f;
 
    for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
        m_speed_rate[i] = 1.0f;
 
    m_charmInfo = nullptr;
 
    _redirectThreatInfo = RedirectThreatInfo();
 
    // remove aurastates allowing special moves
    for (uint8 i = 0; i < MAX_REACTIVE; ++i)
        m_reactiveTimer[i] = 0;
 
    m_cleanupDone = false;
    m_duringRemoveFromWorld = false;
 
    m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_ALIVE);
 
    m_last_notify_position.Relocate(-5000.0f, -5000.0f, -5000.0f, 0.0f);
    m_last_notify_mstime = 0;
    m_delayed_unit_relocation_timer = 0;
    m_delayed_unit_ai_notify_timer = 0;
    bRequestForcedVisibilityUpdate = false;
 
    m_applyResilience = false;
    _instantCast = false;
 
    _lastLiquid = nullptr;
 
    _oldFactionId = 0;
 
    _isWalkingBeforeCharm = false;
 
    _lastExtraAttackSpell = 0;
}

Member Function Documentation

◆ _addAttacker()

void Unit::_addAttacker ( Unit * pAttacker )

inline

Definition at line 1358 of file Unit.h.

    {
        m_attackers.insert(pAttacker);
    }

◆ _AddAura()

void Unit::_AddAura	(	UnitAura *	aura,
		Unit *	caster
	)

Definition at line 4342 of file Unit.cpp.

{
    ASSERT(!m_cleanupDone);
    m_ownedAuras.insert(AuraMap::value_type(aura->GetId(), aura));
 
    _RemoveNoStackAurasDueToAura(aura);
 
    if (aura->IsRemoved())
        return;
 
    aura->SetIsSingleTarget(caster && (aura->GetSpellInfo()->IsSingleTarget() || aura->HasEffectType(SPELL_AURA_CONTROL_VEHICLE)));
    if (aura->IsSingleTarget())
    {
        ASSERT((IsInWorld() && !IsDuringRemoveFromWorld()) || (aura->GetCasterGUID() == GetGUID()));
        /* @HACK: Player is not in world during loading auras.
         *        Single target auras are not saved or loaded from database
         *        but may be created as a result of aura links (player mounts with passengers)
         */
 
        // register single target aura
        caster->GetSingleCastAuras().push_back(aura);
        // remove other single target auras
        Unit::AuraList& scAuras = caster->GetSingleCastAuras();
        for (Unit::AuraList::iterator itr = scAuras.begin(); itr != scAuras.end();)
        {
            if ((*itr) != aura &&
                    (*itr)->IsSingleTargetWith(aura))
            {
                (*itr)->Remove();
                itr = scAuras.begin();
            }
            else
                ++itr;
        }
    }
}

◆ _ApplyAllAuraStatMods()

void Unit::_ApplyAllAuraStatMods ( )

Definition at line 5394 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator i = m_appliedAuras.begin(); i != m_appliedAuras.end(); ++i)
        (*i).second->GetBase()->HandleAllEffects(i->second, AURA_EFFECT_HANDLE_STAT, true);
}

◆ _ApplyAura()

void Unit::_ApplyAura	(	AuraApplication *	aurApp,
		uint8	effMask
	)

Definition at line 4433 of file Unit.cpp.

{
    Aura* aura = aurApp->GetBase();
 
    _RemoveNoStackAurasDueToAura(aura);
 
    if (aurApp->GetRemoveMode())
        return;
 
    Unit* caster = aura->GetCaster();
 
    // Update target aura state flag
    SpellInfo const* spellInfo = aura->GetSpellInfo();
    if (AuraStateType aState = spellInfo->GetAuraState())
    {
        if (aState != AURA_STATE_CONFLAGRATE)
        {
            // Sting (hunter's pet ability), Faerie Fire (druid versions)
            if (aState == AURA_STATE_FAERIE_FIRE)
                aurApp->GetTarget()->RemoveAurasByType(SPELL_AURA_MOD_STEALTH);
 
            ModifyAuraState(aState, true);
        }
        else if (caster)
        {
            ConflagrateAuraStateDelayEvent* pEvent = new ConflagrateAuraStateDelayEvent(this, caster->GetGUID());
            m_Events.AddEvent(pEvent, m_Events.CalculateTime(700)); // intended 700ms delay before allowing to cast conflagrate
        }
    }
 
    if (aurApp->GetRemoveMode())
        return;
 
    // Sitdown on apply aura req seated
    if (spellInfo->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_SEATED && !IsSitState())
        SetStandState(UNIT_STAND_STATE_SIT);
 
    if (aurApp->GetRemoveMode())
        return;
 
    aura->HandleAuraSpecificMods(aurApp, caster, true, false);
 
    // apply effects of the aura
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (effMask & 1 << i && (!aurApp->GetRemoveMode()))
            aurApp->_HandleEffect(i, true);
    }
 
    sScriptMgr->OnAuraApply(this, aura);
}

◆ _ApplyAuraEffect()

void Unit::_ApplyAuraEffect	(	Aura *	aura,
		uint8	effIndex
	)

Definition at line 4419 of file Unit.cpp.

{
    ASSERT(aura);
    ASSERT(aura->HasEffect(effIndex));
    AuraApplication* aurApp = aura->GetApplicationOfTarget(GetGUID());
    ASSERT(aurApp);
    if (!aurApp->GetEffectMask())
        _ApplyAura(aurApp, 1 << effIndex);
    else
        aurApp->_HandleEffect(effIndex, true);
}

◆ _CreateAuraApplication()

AuraApplication * Unit::_CreateAuraApplication	(	Aura *	aura,
		uint8	effMask
	)

Definition at line 4381 of file Unit.cpp.

{
    // can't apply aura on unit which is going to be deleted - to not create a memory leak
    ASSERT(!m_cleanupDone);
    // aura musn't be removed
    ASSERT(!aura->IsRemoved());
 
    // aura mustn't be already applied on target
    ASSERT (!aura->IsAppliedOnTarget(GetGUID()) && "Unit::_CreateAuraApplication: aura musn't be applied on target");
 
    SpellInfo const* aurSpellInfo = aura->GetSpellInfo();
    uint32 aurId = aurSpellInfo->Id;
 
    // ghost spell check, allow apply any auras at player loading in ghost mode (will be cleanup after load)
    // Xinef: Added IsAllowingDeadTarget check
    if (!IsAlive() && !aurSpellInfo->IsDeathPersistent() && !aurSpellInfo->IsAllowingDeadTarget() && (GetTypeId() != TYPEID_PLAYER || !ToPlayer()->GetSession()->PlayerLoading()))
        return nullptr;
 
    Unit* caster = aura->GetCaster();
 
    AuraApplication* aurApp = new AuraApplication(this, caster, aura, effMask);
    m_appliedAuras.insert(AuraApplicationMap::value_type(aurId, aurApp));
 
    // xinef: do not insert our application to interruptible list if application target is not the owner (area auras)
    // xinef: even if it gets removed, it will be reapplied in a second
    if (aurSpellInfo->AuraInterruptFlags && this == aura->GetOwner())
    {
        m_interruptableAuras.push_back(aurApp);
        AddInterruptMask(aurSpellInfo->AuraInterruptFlags);
    }
 
    if (AuraStateType aState = aura->GetSpellInfo()->GetAuraState())
        m_auraStateAuras.insert(AuraStateAurasMap::value_type(aState, aurApp));
 
    aura->_ApplyForTarget(this, caster, aurApp);
    return aurApp;
}

◆ _DeleteRemovedAuras()

void Unit::_DeleteRemovedAuras ( )

protected

Definition at line 3776 of file Unit.cpp.

{
    while (!m_removedAuras.empty())
    {
        delete m_removedAuras.front();
        m_removedAuras.pop_front();
    }
}

◆ _EnterVehicle()

void Unit::_EnterVehicle	(	Vehicle *	vehicle,
		int8	seatId,
		AuraApplication const *	aurApp = `nullptr`
	)

Definition at line 19667 of file Unit.cpp.

{
    // Must be called only from aura handler
    if (!IsAlive() || GetVehicleKit() == vehicle || vehicle->GetBase()->IsOnVehicle(this))
        return;
 
    if (m_vehicle)
    {
        if (m_vehicle == vehicle)
        {
            if (seatId >= 0 && seatId != GetTransSeat())
            {
                LOG_DEBUG("vehicles", "EnterVehicle: {} leave vehicle {} seat {} and enter {}.", GetEntry(), m_vehicle->GetBase()->GetEntry(), GetTransSeat(), seatId);
                ChangeSeat(seatId);
            }
 
            return;
        }
        else
        {
            LOG_DEBUG("vehicles", "EnterVehicle: {} exit {} and enter {}.", GetEntry(), m_vehicle->GetBase()->GetEntry(), vehicle->GetBase()->GetEntry());
            ExitVehicle();
        }
    }
 
    if (!aurApp || aurApp->GetRemoveMode())
        return;
 
    if (Player* player = ToPlayer())
    {
        if (vehicle->GetBase()->GetTypeId() == TYPEID_PLAYER && player->IsInCombat())
            return;
 
        sScriptMgr->AnticheatSetUnderACKmount(player);
        sScriptMgr->AnticheatSetSkipOnePacketForASH(player, true);
 
        InterruptNonMeleeSpells(false);
        player->StopCastingCharm();
        player->StopCastingBindSight();
        Dismount();
        RemoveAurasByType(SPELL_AURA_MOUNTED);
 
        // drop flag at invisible in bg
        if (Battleground* bg = player->GetBattleground())
            bg->EventPlayerDroppedFlag(player);
 
        WorldPacket data(SMSG_ON_CANCEL_EXPECTED_RIDE_VEHICLE_AURA, 0);
        player->GetSession()->SendPacket(&data);
    }
 
    ASSERT(!m_vehicle);
    m_vehicle = vehicle;
 
    if (!m_vehicle->AddPassenger(this, seatId))
    {
        m_vehicle = nullptr;
        return;
    }
 
    // Xinef: remove movement auras when entering vehicle (food buffs etc)
    RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TURNING | AURA_INTERRUPT_FLAG_MOVE);
}

◆ _ExitVehicle()

void Unit::_ExitVehicle ( Position const * exitPosition = nullptr )

Definition at line 19787 of file Unit.cpp.

{
    if (!m_vehicle)
        return;
 
    m_vehicle->RemovePassenger(this);
 
    Player* player = ToPlayer();
 
    // If player is on mouted duel and exits the mount should immediatly lose the duel
    if (player && player->duel && player->duel->IsMounted)
        player->DuelComplete(DUEL_FLED);
 
    // This should be done before dismiss, because there may be some aura removal
    Vehicle* vehicle = m_vehicle;
    Unit* vehicleBase = m_vehicle->GetBase();
    m_vehicle = nullptr;
 
    SetControlled(false, UNIT_STATE_ROOT);      // SMSG_MOVE_FORCE_UNROOT, ~MOVEMENTFLAG_ROOT
 
    Position pos;
    if (!exitPosition)                          // Exit position not specified
        pos = vehicleBase->GetPosition();  // This should use passenger's current position, leaving it as it is now
    // because we calculate positions incorrect (sometimes under map)
    else
        pos = *exitPosition;
 
    // HACK
    if (vehicle->GetVehicleInfo()->m_ID == 380) // Kologarn right arm
        pos.Relocate(1776.0f, -24.0f, 448.75f, 0.0f);
    else if (vehicle->GetVehicleInfo()->m_ID == 91) // Helsman's Ship
        pos.Relocate(2802.18f, 7054.91f, -0.6f, 4.67f);
    else if (vehicle->GetVehicleInfo()->m_ID == 349) // AT Mounts, dismount to the right
    {
        float x = pos.GetPositionX() + 2.0f * cos(pos.GetOrientation() - M_PI / 2.0f);
        float y = pos.GetPositionY() + 2.0f * std::sin(pos.GetOrientation() - M_PI / 2.0f);
        float z = GetMapHeight(x, y, pos.GetPositionZ());
        if (z > INVALID_HEIGHT)
            pos.Relocate(x, y, z);
    }
 
    AddUnitState(UNIT_STATE_MOVE);
 
    if (player)
    {
        player->SetFallInformation(GameTime::GetGameTime().count(), GetPositionZ());
 
        sScriptMgr->AnticheatSetUnderACKmount(player);
        sScriptMgr->AnticheatSetSkipOnePacketForASH(player, true);
    }
    else if (HasUnitMovementFlag(MOVEMENTFLAG_ROOT))
    {
        WorldPacket data(SMSG_SPLINE_MOVE_UNROOT, 8);
        data << GetPackGUID();
        SendMessageToSet(&data, false);
    }
 
    // xinef: hack for flameleviathan seat vehicle
    if (vehicle->GetVehicleInfo()->m_ID != 341)
    {
        Movement::MoveSplineInit init(this);
        init.MoveTo(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ());
        init.SetFacing(GetOrientation());
        init.SetTransportExit();
        init.Launch();
    }
    else
    {
        float o = pos.GetAngle(this);
        Movement::MoveSplineInit init(this);
        init.MoveTo(pos.GetPositionX() + 8 * cos(o), pos.GetPositionY() + 8 * std::sin(o), pos.GetPositionZ() + 16.0f);
        init.SetFacing(GetOrientation());
        init.SetTransportExit();
        init.Launch();
        DisableSpline();
        KnockbackFrom(pos.GetPositionX(), pos.GetPositionY(), 10.0f, 20.0f);
        CastSpell(this, VEHICLE_SPELL_PARACHUTE, true);
    }
 
    // xinef: move fall, should we support all creatures that exited vehicle in air? Currently Quest Drag and Drop only, Air Assault quest
    if (GetTypeId() == TYPEID_UNIT && !CanFly() &&
            (vehicle->GetVehicleInfo()->m_ID == 113 || vehicle->GetVehicleInfo()->m_ID == 8 || vehicle->GetVehicleInfo()->m_ID == 290 || vehicle->GetVehicleInfo()->m_ID == 298))
        GetMotionMaster()->MoveFall();
    //GetMotionMaster()->MoveFall();            // Enable this once passenger positions are calculater properly (see above)
 
    if ((!player || !(player->GetDelayedOperations() & DELAYED_VEHICLE_TELEPORT)) && vehicle->GetBase()->HasUnitTypeMask(UNIT_MASK_MINION))
        if (((Minion*)vehicleBase)->GetOwner() == this)
        {
            if (vehicle->GetVehicleInfo()->m_ID != 349)
                vehicle->Dismiss();
            else if (vehicleBase->GetTypeId() == TYPEID_UNIT)
            {
                vehicle->Uninstall();
                vehicleBase->m_Events.AddEvent(new VehicleDespawnEvent(*vehicleBase, 2000), vehicleBase->m_Events.CalculateTime(2000));
            }
 
            // xinef: ugly hack, no appripriate hook later to cast spell
            if (player)
            {
                if (vehicleBase->GetEntry() == NPC_EIDOLON_WATCHER)
                    player->CastSpell(player, VEHICLE_SPELL_SHADE_CONTROL_END, true);
                else if (vehicleBase->GetEntry() == NPC_LITHE_STALKER)
                    player->CastSpell(player, VEHICLE_SPELL_GEIST_CONTROL_END, true);
            }
        }
 
    if (HasUnitTypeMask(UNIT_MASK_ACCESSORY))
    {
        // Vehicle just died, we die too
        if (vehicleBase->getDeathState() == JUST_DIED)
            setDeathState(JUST_DIED);
        // If for other reason we as minion are exiting the vehicle (ejected, master dismounted) - unsummon
        else
        {
            SetVisible(false);
            ToTempSummon()->UnSummon(2000); // Approximation
        }
    }
 
    if (player)
        player->ResummonPetTemporaryUnSummonedIfAny();
}

◆ _IsNoStackAuraDueToAura()

bool Unit::_IsNoStackAuraDueToAura	(	Aura *	appliedAura,
		Aura *	existingAura
	)		const

◆ _IsValidAssistTarget()

bool Unit::_IsValidAssistTarget	(	Unit const *	target,
		SpellInfo const *	bySpell
	)		const

Definition at line 13890 of file Unit.cpp.

{
    ASSERT(target);
 
    // can assist to self
    if (this == target)
        return true;
 
    // can't assist unattackable units or GMs
    if (target->HasUnitState(UNIT_STATE_UNATTACKABLE)
            || (target->GetTypeId() == TYPEID_PLAYER && target->ToPlayer()->IsGameMaster()))
        return false;
 
    // can't assist own vehicle or passenger
    if (m_vehicle)
        if (IsOnVehicle(target) || m_vehicle->GetBase()->IsOnVehicle(target))
            return false;
 
    // can't assist invisible
    if ((!bySpell || !bySpell->HasAttribute(SPELL_ATTR6_IGNORE_PHASE_SHIFT)) && !CanSeeOrDetect(target, bySpell && bySpell->IsAffectingArea()))
        return false;
 
    // can't assist dead
    if ((!bySpell || !bySpell->IsAllowingDeadTarget()) && !target->IsAlive())
        return false;
 
    // can't assist untargetable
    if ((!bySpell || !bySpell->HasAttribute(SPELL_ATTR6_CAN_TARGET_UNTARGETABLE))
            && target->HasUnitFlag(UNIT_FLAG_NOT_SELECTABLE))
        return false;
 
    if (!bySpell || !bySpell->HasAttribute(SPELL_ATTR6_CAN_ASSIST_IMMUNE_PC))
    {
        // xinef: do not allow to assist non attackable units
        if (target->HasUnitFlag(UNIT_FLAG_NON_ATTACKABLE))
            return false;
 
        if (HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
        {
            if (target->IsImmuneToPC())
                return false;
        }
        else
        {
            if (target->IsImmuneToNPC())
                return false;
        }
    }
 
    // can't assist non-friendly targets
    if (GetReactionTo(target) < REP_NEUTRAL
            && target->GetReactionTo(this) < REP_NEUTRAL
            && (!ToCreature() || !(ToCreature()->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_TREAT_AS_RAID_UNIT)))
        return false;
 
    // PvP case
    if (target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
    {
        Player const* targetPlayerOwner = target->GetAffectingPlayer();
        if (HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
        {
            Player const* selfPlayerOwner = GetAffectingPlayer();
            if (selfPlayerOwner && targetPlayerOwner)
            {
                // can't assist player which is dueling someone
                if (selfPlayerOwner != targetPlayerOwner
                        && targetPlayerOwner->duel)
                    return false;
            }
            // can't assist player in ffa_pvp zone from outside
            if (target->IsFFAPvP() && !IsFFAPvP())
                return false;
 
            // can't assist player out of sanctuary from sanctuary if has pvp enabled
            if (target->IsPvP())
                if (IsInSanctuary() && !target->IsInSanctuary())
                    return false;
        }
    }
    // PvC case - player can assist creature only if has specific type flags
    // !target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) &&
    else if (HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED)
             && (!bySpell || !bySpell->HasAttribute(SPELL_ATTR6_CAN_ASSIST_IMMUNE_PC))
             && !target->IsPvP())
    {
        if (Creature const* creatureTarget = target->ToCreature())
            return creatureTarget->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_TREAT_AS_RAID_UNIT || creatureTarget->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_CAN_ASSIST;
    }
    return true;
}

◆ _IsValidAttackTarget()

bool Unit::_IsValidAttackTarget	(	Unit const *	target,
		SpellInfo const *	bySpell,
		WorldObject const *	obj = `nullptr`
	)		const

Definition at line 13770 of file Unit.cpp.

{
    ASSERT(target);
 
    // can't attack self
    if (this == target)
        return false;
 
    // can't attack unattackable units or GMs
    if (target->HasUnitState(UNIT_STATE_UNATTACKABLE)
            || (target->GetTypeId() == TYPEID_PLAYER && target->ToPlayer()->IsGameMaster()))
        return false;
 
    // can't attack own vehicle or passenger
    if (m_vehicle)
        if (IsOnVehicle(target) || m_vehicle->GetBase()->IsOnVehicle(target))
            if (!IsHostileTo(target)) // pussywizard: actually can attack own vehicle or passenger if it's hostile to us - needed for snobold in Gormok encounter
                return false;
 
    // can't attack invisible (ignore stealth for aoe spells) also if the area being looked at is from a spell use the dynamic object created instead of the casting unit.
    //Ignore stealth if target is player and unit in combat with same player
    if ((!bySpell || !bySpell->HasAttribute(SPELL_ATTR6_IGNORE_PHASE_SHIFT)) && (obj ? !obj->CanSeeOrDetect(target, bySpell && bySpell->IsAffectingArea()) : !CanSeeOrDetect(target, (bySpell && bySpell->IsAffectingArea()) || (target->GetTypeId() == TYPEID_PLAYER && target->HasStealthAura() && target->IsInCombat() && IsInCombatWith(target)))))
        return false;
 
    // can't attack dead
    if ((!bySpell || !bySpell->IsAllowingDeadTarget()) && !target->IsAlive())
        return false;
 
    // can't attack untargetable
    if ((!bySpell || !bySpell->HasAttribute(SPELL_ATTR6_CAN_TARGET_UNTARGETABLE))
            && target->HasUnitFlag(UNIT_FLAG_NOT_SELECTABLE))
        return false;
 
    if (Player const* playerAttacker = ToPlayer())
    {
        if (playerAttacker->HasPlayerFlag(PLAYER_FLAGS_UBER) || playerAttacker->IsSpectator())
            return false;
    }
    // check flags
    if (target->HasUnitFlag(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_TAXI_FLIGHT | UNIT_FLAG_NOT_ATTACKABLE_1 | UNIT_FLAG_NON_ATTACKABLE_2)
            || (!HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) && target->IsImmuneToNPC())
            || (!target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) && IsImmuneToNPC())
            || (HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) && target->IsImmuneToPC())
            // check if this is a world trigger cast - GOs are using world triggers to cast their spells, so we need to ignore their immunity flag here, this is a temp workaround, needs removal when go cast is implemented properly
            || ((GetEntry() != WORLD_TRIGGER && (!obj || !obj->isType(TYPEMASK_GAMEOBJECT | TYPEMASK_DYNAMICOBJECT))) && target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) && IsImmuneToPC()))
        return false;
 
    // CvC case - can attack each other only when one of them is hostile
    if (!HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) && !target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
        return GetReactionTo(target) <= REP_HOSTILE || target->GetReactionTo(this) <= REP_HOSTILE;
 
    // PvP, PvC, CvP case
    // can't attack friendly targets
    ReputationRank repThisToTarget = GetReactionTo(target);
    ReputationRank repTargetToThis;
 
    if (repThisToTarget > REP_NEUTRAL
            || (repTargetToThis = target->GetReactionTo(this)) > REP_NEUTRAL)
        return false;
 
    // Not all neutral creatures can be attacked (even some unfriendly faction does not react aggresive to you, like Sporaggar)
    if (repThisToTarget == REP_NEUTRAL &&
            repTargetToThis <= REP_NEUTRAL)
    {
        Player* owner = GetAffectingPlayer();
        Unit const* const thisUnit = owner ? owner : this;
        if  (!(target->GetTypeId() == TYPEID_PLAYER && thisUnit->GetTypeId() == TYPEID_PLAYER) &&
                !(target->GetTypeId() == TYPEID_UNIT && thisUnit->GetTypeId() == TYPEID_UNIT))
        {
            Player const* player = target->GetTypeId() == TYPEID_PLAYER ? target->ToPlayer() : thisUnit->ToPlayer();
            Unit const* creature = target->GetTypeId() == TYPEID_UNIT ? target : thisUnit;
 
            if (FactionTemplateEntry const* factionTemplate = creature->GetFactionTemplateEntry())
            {
                if (!(player->GetReputationMgr().GetForcedRankIfAny(factionTemplate)))
                    if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionTemplate->faction))
                        if (FactionState const* repState = player->GetReputationMgr().GetState(factionEntry))
                            if (!(repState->Flags & FACTION_FLAG_AT_WAR))
                                return false;
            }
        }
    }
 
    Creature const* creatureAttacker = ToCreature();
    if (creatureAttacker && creatureAttacker->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_TREAT_AS_RAID_UNIT)
        return false;
 
    Player const* playerAffectingAttacker = HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) ? GetAffectingPlayer() : nullptr;
    Player const* playerAffectingTarget = target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) ? target->GetAffectingPlayer() : nullptr;
 
    // check duel - before sanctuary checks
    if (playerAffectingAttacker && playerAffectingTarget)
        if (playerAffectingAttacker->duel && playerAffectingAttacker->duel->Opponent == playerAffectingTarget && playerAffectingAttacker->duel->State == DUEL_STATE_IN_PROGRESS)
            return true;
 
    // PvP case - can't attack when attacker or target are in sanctuary
    // however, 13850 client doesn't allow to attack when one of the unit's has sanctuary flag and is pvp
    if (target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) && HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED) && (target->IsInSanctuary() || IsInSanctuary()))
        return false;
 
    // additional checks - only PvP case
    if (playerAffectingAttacker && playerAffectingTarget)
    {
        if (target->IsPvP())
            return true;
 
        if (IsFFAPvP() && target->IsFFAPvP())
            return true;
 
        return HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_UNK1) || target->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_UNK1);
    }
    return true;
}

◆ _RegisterAuraEffect()

void Unit::_RegisterAuraEffect	(	AuraEffect *	aurEff,
		bool	apply
	)

Definition at line 4616 of file Unit.cpp.

{
    if (apply)
        m_modAuras[aurEff->GetAuraType()].push_back(aurEff);
    else
        m_modAuras[aurEff->GetAuraType()].remove(aurEff);
}

◆ _RegisterDynObject()

void Unit::_RegisterDynObject ( DynamicObject * dynObj )

Definition at line 6018 of file Unit.cpp.

{
    m_dynObj.push_back(dynObj);
}

◆ _RemoveAllAuraStatMods()

void Unit::_RemoveAllAuraStatMods ( )

Definition at line 5388 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator i = m_appliedAuras.begin(); i != m_appliedAuras.end(); ++i)
        (*i).second->GetBase()->HandleAllEffects(i->second, AURA_EFFECT_HANDLE_STAT, false);
}

◆ _removeAttacker()

void Unit::_removeAttacker ( Unit * pAttacker )

inline

Definition at line 1362 of file Unit.h.

    {
        m_attackers.erase(pAttacker);
    }

◆ _RemoveNoStackAuraApplicationsDueToAura()

void Unit::_RemoveNoStackAuraApplicationsDueToAura ( Aura * aura )

◆ _RemoveNoStackAurasDueToAura()

void Unit::_RemoveNoStackAurasDueToAura ( Aura * aura )

Definition at line 4587 of file Unit.cpp.

{
    //SpellInfo const* spellProto = aura->GetSpellInfo();
 
    // passive spell special case (only non stackable with ranks)
 
    // xinef: this check makes caster to have 2 area auras thanks to spec switch
    // if (spellProto->IsPassiveStackableWithRanks())
    //    return;
 
    bool remove = false;
    for (AuraApplicationMap::iterator i = m_appliedAuras.begin(); i != m_appliedAuras.end(); ++i)
    {
        if (remove)
        {
            remove = false;
            i = m_appliedAuras.begin();
        }
 
        if (aura->CanStackWith(i->second->GetBase(), true))
            continue;
 
        RemoveAura(i, AURA_REMOVE_BY_DEFAULT);
        if (i == m_appliedAuras.end())
            break;
        remove = true;
    }
}

◆ _TryStackingOrRefreshingExistingAura()

Aura * Unit::_TryStackingOrRefreshingExistingAura	(	SpellInfo const *	newAura,
		uint8	effMask,
		Unit *	caster,
		int32 *	baseAmount = `nullptr`,
		Item *	castItem = `nullptr`,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		bool	periodicReset = `false`
	)

Definition at line 4282 of file Unit.cpp.

{
    ASSERT(casterGUID || caster);
    if (!casterGUID)
        casterGUID = caster->GetGUID();
 
    // Xinef: Hax for mixology, best solution qq
    if (sSpellMgr->GetSpellGroup(newAura->Id) == 1)
        return nullptr;
 
    // passive and Incanter's Absorption and auras with different type can stack with themselves any number of times
    if (!newAura->IsMultiSlotAura())
    {
        // check if cast item changed
        ObjectGuid castItemGUID;
        if (castItem)
            castItemGUID = castItem->GetGUID();
 
        // find current aura from spell and change it's stackamount, or refresh it's duration
        if (Aura* foundAura = GetOwnedAura(newAura->Id, newAura->HasAttribute(SPELL_ATTR0_CU_SINGLE_AURA_STACK) ? ObjectGuid::Empty : casterGUID, newAura->HasAttribute(SPELL_ATTR0_CU_ENCHANT_PROC) ? castItemGUID : ObjectGuid::Empty, 0))
        {
            // effect masks do not match
            // extremely rare case
            // let's just recreate aura
            if (effMask != foundAura->GetEffectMask())
                return nullptr;
 
            // update basepoints with new values - effect amount will be recalculated in ModStackAmount
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (!foundAura->HasEffect(i))
                    continue;
 
                int bp;
                if (baseAmount)
                    bp = *(baseAmount + i);
                else
                    bp = foundAura->GetSpellInfo()->Effects[i].BasePoints;
 
                int32* oldBP = const_cast<int32*>(&(foundAura->GetEffect(i)->m_baseAmount));
                *oldBP = bp;
            }
 
            // correct cast item guid if needed
            if (castItemGUID != foundAura->GetCastItemGUID())
            {
                ObjectGuid* oldGUID = const_cast<ObjectGuid*>(&foundAura->m_castItemGuid);
                *oldGUID = castItemGUID;
            }
 
            // try to increase stack amount
            foundAura->ModStackAmount(1, AURA_REMOVE_BY_DEFAULT, periodicReset);
            sScriptMgr->OnAuraApply(this, foundAura);
            return foundAura;
        }
    }
 
    return nullptr;
}

◆ _UnapplyAura() [1/2]

void Unit::_UnapplyAura	(	AuraApplication *	aurApp,
		AuraRemoveMode	removeMode
	)

Definition at line 4566 of file Unit.cpp.

{
    // aura can be removed from unit only if it's applied on it, shouldn't happen
    ASSERT(aurApp->GetBase()->GetApplicationOfTarget(GetGUID()) == aurApp);
 
    uint32 spellId = aurApp->GetBase()->GetId();
    AuraApplicationMapBoundsNonConst range = m_appliedAuras.equal_range(spellId);
 
    for (AuraApplicationMap::iterator iter = range.first; iter != range.second;)
    {
        if (iter->second == aurApp)
        {
            _UnapplyAura(iter, removeMode);
            return;
        }
        else
            ++iter;
    }
    ABORT();
}

◆ _UnapplyAura() [2/2]

void Unit::_UnapplyAura	(	AuraApplicationMap::iterator &	i,
		AuraRemoveMode	removeMode
	)

Definition at line 4486 of file Unit.cpp.

{
    AuraApplication* aurApp = i->second;
    ASSERT(aurApp);
    ASSERT(!aurApp->GetRemoveMode());
    ASSERT(aurApp->GetTarget() == this);
 
    aurApp->SetRemoveMode(removeMode);
    Aura* aura = aurApp->GetBase();
    LOG_DEBUG("spells.aura", "Aura {} now is remove mode {}", aura->GetId(), removeMode);
 
    // dead loop is killing the server probably
    ASSERT(m_removedAurasCount < 0xFFFFFFFF);
 
    ++m_removedAurasCount;
 
    Unit* caster = aura->GetCaster();
 
    // Remove all pointers from lists here to prevent possible pointer invalidation on spellcast/auraapply/auraremove
    m_appliedAuras.erase(i);
 
    // xinef: do not insert our application to interruptible list if application target is not the owner (area auras)
    // xinef: event if it gets removed, it will be reapplied in a second
    if (aura->GetSpellInfo()->AuraInterruptFlags && this == aura->GetOwner())
    {
        m_interruptableAuras.remove(aurApp);
        UpdateInterruptMask();
    }
 
    bool auraStateFound = false;
    AuraStateType auraState = aura->GetSpellInfo()->GetAuraState();
    if (auraState)
    {
        bool canBreak = false;
        // Get mask of all aurastates from remaining auras
        for (AuraStateAurasMap::iterator itr = m_auraStateAuras.lower_bound(auraState); itr != m_auraStateAuras.upper_bound(auraState) && !(auraStateFound && canBreak);)
        {
            if (itr->second == aurApp)
            {
                m_auraStateAuras.erase(itr);
                itr = m_auraStateAuras.lower_bound(auraState);
                canBreak = true;
                continue;
            }
            auraStateFound = true;
            ++itr;
        }
    }
 
    aurApp->_Remove();
    aura->_UnapplyForTarget(this, caster, aurApp);
 
    // remove effects of the spell - needs to be done after removing aura from lists
    for (uint8 itr = 0; itr < MAX_SPELL_EFFECTS; ++itr)
    {
        if (aurApp->HasEffect(itr))
            aurApp->_HandleEffect(itr, false);
    }
 
    // all effect mustn't be applied
    ASSERT(!aurApp->GetEffectMask());
 
    // Remove totem at next update if totem loses its aura
    if (aurApp->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE && IsTotem() && GetGUID() == aura->GetCasterGUID())
    {
        if (ToTotem()->GetSpell() == aura->GetId() && ToTotem()->GetTotemType() == TOTEM_PASSIVE)
            ToTotem()->setDeathState(JUST_DIED);
    }
 
    // Remove aurastates only if were not found
    if (!auraStateFound)
        ModifyAuraState(auraState, false);
 
    aura->HandleAuraSpecificMods(aurApp, caster, false, false);
 
    // only way correctly remove all auras from list
    //if (removedAuras != m_removedAurasCount) new aura may be added
    i = m_appliedAuras.begin();
}

◆ _UnregisterDynObject()

void Unit::_UnregisterDynObject ( DynamicObject * dynObj )

Definition at line 6023 of file Unit.cpp.

{
    m_dynObj.remove(dynObj);
}

◆ _UpdateAutoRepeatSpell()

void Unit::_UpdateAutoRepeatSpell ( )

protected

Definition at line 3841 of file Unit.cpp.

{
    SpellInfo const* spellProto = nullptr;
    if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL])
    {
        spellProto = m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo;
    }
 
    if (!spellProto)
    {
        return;
    }
 
    static uint32 const HUNTER_AUTOSHOOT = 75;
 
    // Check "realtime" interrupts
    if ((GetTypeId() == TYPEID_PLAYER && ToPlayer()->isMoving() && spellProto->Id != HUNTER_AUTOSHOOT) || IsNonMeleeSpellCast(false, false, true, spellProto->Id == HUNTER_AUTOSHOOT))
    {
        // cancel wand shoot
        if (spellProto->Id != HUNTER_AUTOSHOOT)
            InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
        m_AutoRepeatFirstCast = true;
        return;
    }
 
    // Apply delay (Hunter's autoshoot not affected)
    if (m_AutoRepeatFirstCast && getAttackTimer(RANGED_ATTACK) < 500 && spellProto->Id != HUNTER_AUTOSHOOT)
    {
        setAttackTimer(RANGED_ATTACK, 500);
    }
 
    m_AutoRepeatFirstCast = false;
 
    // Check for ranged attack timer
    if (isAttackReady(RANGED_ATTACK))
    {
        SpellCastResult result = m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->CheckCast(true);
        if (result != SPELL_CAST_OK)
        {
            if (spellProto->Id != HUNTER_AUTOSHOOT)
            {
                InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
            }
 
            return;
        }
 
        // We want to shoot
        Spell* spell = new Spell(this, spellProto, TRIGGERED_FULL_MASK);
        spell->prepare(&(m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_targets));
 
        // Reset attack
        resetAttackTimer(RANGED_ATTACK);
    }
}

◆ _UpdateSpells()

void Unit::_UpdateSpells ( uint32 time )

protected

Definition at line 3785 of file Unit.cpp.

{
    if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL])
        _UpdateAutoRepeatSpell();
 
    // remove finished spells from current pointers
    for (uint32 i = 0; i < CURRENT_MAX_SPELL; ++i)
    {
        if (m_currentSpells[i] && m_currentSpells[i]->getState() == SPELL_STATE_FINISHED)
        {
            m_currentSpells[i]->SetReferencedFromCurrent(false);
            m_currentSpells[i] = nullptr;                      // remove pointer
        }
    }
 
    // m_auraUpdateIterator can be updated in indirect called code at aura remove to skip next planned to update but removed auras
    for (m_auraUpdateIterator = m_ownedAuras.begin(); m_auraUpdateIterator != m_ownedAuras.end();)
    {
        Aura* i_aura = m_auraUpdateIterator->second;
        ++m_auraUpdateIterator;                            // need shift to next for allow update if need into aura update
        i_aura->UpdateOwner(time, this);
    }
 
    // remove expired auras - do that after updates(used in scripts?)
    for (AuraMap::iterator i = m_ownedAuras.begin(); i != m_ownedAuras.end();)
    {
        if (i->second->IsExpired())
            RemoveOwnedAura(i, AURA_REMOVE_BY_EXPIRE);
        else
            ++i;
    }
 
    for (VisibleAuraMap::iterator itr = m_visibleAuras.begin(); itr != m_visibleAuras.end(); ++itr)
        if (itr->second->IsNeedClientUpdate())
            itr->second->ClientUpdate();
 
    _DeleteRemovedAuras();
 
    if (!m_gameObj.empty())
    {
        for (GameObjectList::iterator itr = m_gameObj.begin(); itr != m_gameObj.end();)
        {
            if (GameObject* go = ObjectAccessor::GetGameObject(*this, *itr))
                if (!go->isSpawned())
                {
                    go->SetOwnerGUID(ObjectGuid::Empty);
                    go->SetRespawnTime(0);
                    go->Delete();
                    m_gameObj.erase(itr++);
                    continue;
                }
            ++itr;
        }
    }
}

◆ AddAura() [1/2]

Aura * Unit::AddAura	(	SpellInfo const *	spellInfo,
		uint8	effMask,
		Unit *	target
	)

Definition at line 18910 of file Unit.cpp.

{
    if (!spellInfo)
        return nullptr;
 
    if (target->IsImmunedToSpell(spellInfo))
        return nullptr;
 
    for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (!(effMask & (1 << i)))
            continue;
        if (target->IsImmunedToSpellEffect(spellInfo, i))
            effMask &= ~(1 << i);
    }
 
    if (Aura* aura = Aura::TryRefreshStackOrCreate(spellInfo, effMask, target, this))
    {
        aura->ApplyForTargets();
        return aura;
    }
    return nullptr;
}

◆ AddAura() [2/2]

Aura * Unit::AddAura	(	uint32	spellId,
		Unit *	target
	)

Definition at line 18895 of file Unit.cpp.

{
    if (!target)
        return nullptr;
 
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
        return nullptr;
 
    if (!target->IsAlive() && !spellInfo->HasAttribute(SPELL_ATTR0_PASSIVE) && !spellInfo->HasAttribute(SPELL_ATTR2_ALLOW_DEAD_TARGET))
        return nullptr;
 
    return AddAura(spellInfo, MAX_EFFECT_MASK, target);
}

◆ AddComboPointHolder()

void Unit::AddComboPointHolder ( Unit * unit )

inline

Definition at line 2294 of file Unit.h.

2294{ m_ComboPointHolders.insert(unit); }

Unit::m_ComboPointHolders

std::unordered_set< Unit * > m_ComboPointHolders

Definition: Unit.h:2577

◆ AddComboPoints() [1/2]

void Unit::AddComboPoints ( int8 count )

inline

Definition at line 2290 of file Unit.h.

2290{ AddComboPoints(nullptr, count); }

Unit::AddComboPoints

void AddComboPoints(Unit *target, int8 count)

Definition: Unit.cpp:16899

◆ AddComboPoints() [2/2]

void Unit::AddComboPoints	(	Unit *	target,
		int8	count
	)

Definition at line 16899 of file Unit.cpp.

{
    if (!count)
    {
        return;
    }
 
    if (target && target != m_comboTarget)
    {
        if (m_comboTarget)
        {
            m_comboTarget->RemoveComboPointHolder(this);
        }
 
        m_comboTarget = target;
        m_comboPoints = count;
        target->AddComboPointHolder(this);
    }
    else
    {
        m_comboPoints = std::max<int8>(std::min<int8>(m_comboPoints + count, 5), 0);
    }
 
    SendComboPoints();
}

◆ AddExtraAttacks()

void Unit::AddExtraAttacks ( uint32 count )

Definition at line 2715 of file Unit.cpp.

{
    ObjectGuid targetGUID = _lastDamagedTargetGuid;
    if (!targetGUID)
    {
        if (ObjectGuid selection = GetTarget())
        {
            targetGUID = selection; // Spell was cast directly (not triggered by aura)
        }
        else
            return;
    }
 
    extraAttacksTargets[targetGUID] += count;
}

◆ AddExtraUnitMovementFlag()

void Unit::AddExtraUnitMovementFlag ( uint16 f )

inline

Definition at line 2273 of file Unit.h.

2273{ m_movementInfo.flags2 |= f; }

MovementInfo::flags2

uint16 flags2

Definition: Object.h:268

WorldObject::m_movementInfo

MovementInfo m_movementInfo

Definition: Object.h:595

◆ addFollower()

void Unit::addFollower ( FollowerReference * pRef )

inline

Definition at line 2254 of file Unit.h.

2254{ m_FollowingRefMgr.insertFirst(pRef); }

LinkedListHead::insertFirst

void insertFirst(LinkedListElement *pElem)

Definition: LinkedList.h:105

Unit::m_FollowingRefMgr

FollowerRefMgr m_FollowingRefMgr

Definition: Unit.h:2573

◆ AddGameObject()

void Unit::AddGameObject ( GameObject * gameObj )

Definition at line 6079 of file Unit.cpp.

{
    if (!gameObj || gameObj->GetOwnerGUID())
        return;
 
    m_gameObj.push_back(gameObj->GetGUID());
    gameObj->SetOwnerGUID(GetGUID());
 
    if (GetTypeId() == TYPEID_PLAYER && gameObj->GetSpellId())
    {
        SpellInfo const* createBySpell = sSpellMgr->GetSpellInfo(gameObj->GetSpellId());
        // Need disable spell use for owner
        if (createBySpell && createBySpell->IsCooldownStartedOnEvent())
            // note: item based cooldowns and cooldown spell mods with charges ignored (unknown existing cases)
            ToPlayer()->AddSpellAndCategoryCooldowns(createBySpell, 0, nullptr, true);
    }
}

◆ addHatedBy()

void Unit::addHatedBy ( HostileReference * pHostileReference )

inline

Definition at line 2144 of file Unit.h.

2144{ m_HostileRefMgr.insertFirst(pHostileReference); };

◆ AddInterruptMask()

void Unit::AddInterruptMask ( uint32 mask )

inline

Definition at line 2160 of file Unit.h.

2160{ m_interruptMask |= mask; }

◆ AddPetAura()

void Unit::AddPetAura ( PetAura const * petSpell )

Definition at line 17347 of file Unit.cpp.

{
    if (GetTypeId() != TYPEID_PLAYER)
        return;
 
    m_petAuras.insert(petSpell);
    if (Pet* pet = ToPlayer()->GetPet())
        pet->CastPetAura(petSpell);
    else if (Unit* charm = GetCharm())
        charm->CastPetAura(petSpell);
}

◆ AddPlayerToVision()

void Unit::AddPlayerToVision ( Player * player )

Definition at line 11117 of file Unit.cpp.

{
    if (m_sharedVision.empty())
    {
        setActive(true);
        SetWorldObject(true);
    }
    m_sharedVision.push_back(player);
    player->m_isInSharedVisionOf.insert(this);
}

◆ AddPointedBy()

void Unit::AddPointedBy ( SafeUnitPointer * sup )

inline

Definition at line 2400 of file Unit.h.

2400{ SafeUnitPointerSet.insert(sup); }

Unit::SafeUnitPointerSet

std::set< SafeUnitPointer * > SafeUnitPointerSet

Definition: Unit.h:2399

◆ AddSpellCooldown()

virtual void Unit::AddSpellCooldown	(	uint32	,
		uint32	,
		uint32	,
		bool	needSendToClient = `false`,
		bool	forceSendToSpectator = `false`
	)

inlinevirtual

Reimplemented in Player, and Creature.

Definition at line 2415 of file Unit.h.

    {
        // workaround for unused parameters
        (void)needSendToClient;
        (void)forceSendToSpectator;
    }

◆ AddThreat()

void Unit::AddThreat	(	Unit *	victim,
		float	fThreat,
		SpellSchoolMask	schoolMask = `SPELL_SCHOOL_MASK_NORMAL`,
		SpellInfo const *	threatSpell = `nullptr`
	)

Definition at line 14523 of file Unit.cpp.

{
    // Only mobs can manage threat lists
    if (CanHaveThreatList() && !HasUnitState(UNIT_STATE_EVADE))
    {
        m_ThreatMgr.AddThreat(victim, fThreat, schoolMask, threatSpell);
    }
}

◆ AddToWorld()

void Unit::AddToWorld ( )

overridevirtual

Reimplemented from WorldObject.

Definition at line 15525 of file Unit.cpp.

{
    if (!IsInWorld())
    {
        WorldObject::AddToWorld();
    }
}

◆ AddUnitMovementFlag()

void Unit::AddUnitMovementFlag ( uint32 f )

inline

Definition at line 2267 of file Unit.h.

2267{ m_movementInfo.flags |= f; }

MovementInfo::flags

uint32 flags

Definition: Object.h:267

◆ AddUnitState()

void Unit::AddUnitState ( uint32 f )

inline

Definition at line 1397 of file Unit.h.

1397{ m_state |= f; }

◆ AddUnitTypeMask()

void Unit::AddUnitTypeMask ( uint32 mask )

inline

Definition at line 1408 of file Unit.h.

1408{ m_unitTypeMask |= mask; }

◆ ApplyAttackTimePercentMod()

void Unit::ApplyAttackTimePercentMod	(	WeaponAttackType	att,
		float	val,
		bool	apply
	)

Definition at line 17115 of file Unit.cpp.

{
    float remainingTimePct = std::max((float)m_attackTimer[att], 0.0f) / (GetAttackTime(att) * m_modAttackSpeedPct[att]);
    if (val > 0)
    {
        ApplyPercentModFloatVar(m_modAttackSpeedPct[att], val, !apply);
        ApplyPercentModFloatValue(static_cast<uint16>(UNIT_FIELD_BASEATTACKTIME) + att, val, !apply);
    }
    else
    {
        ApplyPercentModFloatVar(m_modAttackSpeedPct[att], -val, apply);
        ApplyPercentModFloatValue(static_cast<uint16>(UNIT_FIELD_BASEATTACKTIME) + att, -val, apply);
    }
    m_attackTimer[att] = uint32(GetAttackTime(att) * m_modAttackSpeedPct[att] * remainingTimePct);
}

◆ ApplyCastTimePercentMod()

void Unit::ApplyCastTimePercentMod	(	float	val,
		bool	apply
	)

Definition at line 17131 of file Unit.cpp.

{
    if (val > 0)
        ApplyPercentModFloatValue(UNIT_MOD_CAST_SPEED, val, !apply);
    else
        ApplyPercentModFloatValue(UNIT_MOD_CAST_SPEED, -val, apply);
}

◆ ApplyDiminishingAura()

void Unit::ApplyDiminishingAura	(	DiminishingGroup	group,
		bool	apply
	)

Definition at line 14983 of file Unit.cpp.

{
    // Checking for existing in the table
    for (Diminishing::iterator i = m_Diminishing.begin(); i != m_Diminishing.end(); ++i)
    {
        if (i->DRGroup != group)
            continue;
 
        if (apply)
            i->stack += 1;
        else if (i->stack)
        {
            i->stack -= 1;
            // Remember time after last aura from group removed
            if (i->stack == 0)
                i->hitTime = GameTime::GetGameTimeMS().count();
        }
        break;
    }
}

◆ ApplyDiminishingToDuration()

float Unit::ApplyDiminishingToDuration	(	DiminishingGroup	group,
		int32 &	duration,
		Unit *	caster,
		DiminishingLevels	Level,
		int32	limitduration
	)

Definition at line 14904 of file Unit.cpp.

{
    // xinef: dont apply diminish to self casts
    if (duration == -1 || group == DIMINISHING_NONE)
        return 1.0f;
 
    // test pet/charm masters instead pets/charmeds
    Unit const* targetOwner = GetOwner();
    Unit const* casterOwner = caster->GetOwner();
 
    // Duration of crowd control abilities on pvp target is limited by 10 sec. (2.2.0)
    if (limitduration > 0 && duration > limitduration)
    {
        Unit const* target = targetOwner ? targetOwner : this;
        Unit const* source = casterOwner ? casterOwner : caster;
 
        if ((target->GetTypeId() == TYPEID_PLAYER
                || target->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_ALL_DIMINISH)
                && source->GetTypeId() == TYPEID_PLAYER)
            duration = limitduration;
    }
 
    float mod = 1.0f;
 
    if (group == DIMINISHING_TAUNT)
    {
        if (GetTypeId() == TYPEID_UNIT && (ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_OBEYS_TAUNT_DIMINISHING_RETURNS))
        {
            DiminishingLevels diminish = Level;
            switch (diminish)
            {
                case DIMINISHING_LEVEL_1:
                    break;
                case DIMINISHING_LEVEL_2:
                    mod = 0.65f;
                    break;
                case DIMINISHING_LEVEL_3:
                    mod = 0.4225f;
                    break;
                case DIMINISHING_LEVEL_4:
                    mod = 0.274625f;
                    break;
                case DIMINISHING_LEVEL_TAUNT_IMMUNE:
                    mod = 0.0f;
                    break;
                default:
                    break;
            }
        }
    }
    // Some diminishings applies to mobs too (for example, Stun)
    else if ((GetDiminishingReturnsGroupType(group) == DRTYPE_PLAYER
              && ((targetOwner ? (targetOwner->GetTypeId() == TYPEID_PLAYER) : (GetTypeId() == TYPEID_PLAYER))
                  || (GetTypeId() == TYPEID_UNIT && ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_ALL_DIMINISH)))
             || GetDiminishingReturnsGroupType(group) == DRTYPE_ALL)
    {
        DiminishingLevels diminish = Level;
        switch (diminish)
        {
            case DIMINISHING_LEVEL_1:
                break;
            case DIMINISHING_LEVEL_2:
                mod = 0.5f;
                break;
            case DIMINISHING_LEVEL_3:
                mod = 0.25f;
                break;
            case DIMINISHING_LEVEL_IMMUNE:
                mod = 0.0f;
                break;
            default:
                break;
        }
    }
 
    duration = int32(duration * mod);
    return mod;
}

◆ ApplyEffectModifiers()

float Unit::ApplyEffectModifiers	(	SpellInfo const *	spellProto,
		uint8	effect_index,
		float	value
	)		const

Definition at line 14686 of file Unit.cpp.

{
    if (Player* modOwner = GetSpellModOwner())
    {
        modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_ALL_EFFECTS, value);
        switch (effect_index)
        {
            case 0:
                modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT1, value);
                break;
            case 1:
                modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT2, value);
                break;
            case 2:
                modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT3, value);
                break;
        }
    }
    return value;
}

◆ ApplyResilience()

void Unit::ApplyResilience	(	Unit const *	victim,
		float *	crit,
		int32 *	damage,
		bool	isCrit,
		CombatRating	type
	)

static

Definition at line 18959 of file Unit.cpp.

{
    // player mounted on multi-passenger mount is also classified as vehicle
    if (victim->IsVehicle() && victim->GetTypeId() != TYPEID_PLAYER)
        return;
 
    Unit const* target = nullptr;
    if (victim->GetTypeId() == TYPEID_PLAYER)
        target = victim;
    else if (victim->GetTypeId() == TYPEID_UNIT)
    {
        if (Unit* owner = victim->GetOwner())
            if (owner->GetTypeId() == TYPEID_PLAYER)
                target = owner;
    }
 
    if (!target)
        return;
 
    switch (type)
    {
        case CR_CRIT_TAKEN_MELEE:
            // Crit chance reduction works against nonpets
            if (crit)
                *crit -= target->GetMeleeCritChanceReduction();
            if (damage)
            {
                if (isCrit)
                    *damage -= target->GetMeleeCritDamageReduction(*damage);
                *damage -= target->GetMeleeDamageReduction(*damage);
            }
            break;
        case CR_CRIT_TAKEN_RANGED:
            // Crit chance reduction works against nonpets
            if (crit)
                *crit -= target->GetRangedCritChanceReduction();
            if (damage)
            {
                if (isCrit)
                    *damage -= target->GetRangedCritDamageReduction(*damage);
                *damage -= target->GetRangedDamageReduction(*damage);
            }
            break;
        case CR_CRIT_TAKEN_SPELL:
            // Crit chance reduction works against nonpets
            if (crit)
                *crit -= target->GetSpellCritChanceReduction();
            if (damage)
            {
                if (isCrit)
                    *damage -= target->GetSpellCritDamageReduction(*damage);
                *damage -= target->GetSpellDamageReduction(*damage);
            }
            break;
        default:
            break;
    }
}

◆ ApplyResistanceBuffModsMod()

void Unit::ApplyResistanceBuffModsMod	(	SpellSchools	school,
		bool	positive,
		float	val,
		bool	apply
	)

inline

Definition at line 2024 of file Unit.h.

2024{ ApplyModSignedFloatValue(positive ? static_cast<uint16>(UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE) + school : static_cast<uint16>(UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE) + + school, val, apply); }

UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE

@ UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE

Definition: UpdateFields.h:157

UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE

@ UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE

Definition: UpdateFields.h:158

Object::ApplyModSignedFloatValue

void ApplyModSignedFloatValue(uint16 index, float val, bool apply)

Definition: Object.cpp:822

◆ ApplyResistanceBuffModsPercentMod()

void Unit::ApplyResistanceBuffModsPercentMod	(	SpellSchools	school,
		bool	positive,
		float	val,
		bool	apply
	)

inline

Definition at line 2025 of file Unit.h.

2025{ ApplyPercentModFloatValue(positive ? static_cast<uint16>(UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE) + school : static_cast<uint16>(UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE) + + school, val, apply); }

◆ ApplySpellDispelImmunity()

void Unit::ApplySpellDispelImmunity	(	SpellInfo const *	spellProto,
		DispelType	type,
		bool	apply
	)

Definition at line 13320 of file Unit.cpp.

{
    ApplySpellImmune(spellProto->Id, IMMUNITY_DISPEL, type, apply);
 
    if (apply && spellProto->HasAttribute(SPELL_ATTR1_IMMUNITY_PURGES_EFFECT))
    {
        // Create dispel mask by dispel type
        uint32 dispelMask = SpellInfo::GetDispelMask(type);
        // Dispel all existing auras vs current dispel type
        AuraApplicationMap& auras = GetAppliedAuras();
        for (AuraApplicationMap::iterator itr = auras.begin(); itr != auras.end();)
        {
            SpellInfo const* spell = itr->second->GetBase()->GetSpellInfo();
            if (spell->GetDispelMask() & dispelMask)
            {
                // Dispel aura
                RemoveAura(itr);
            }
            else
                ++itr;
        }
    }
}

◆ ApplySpellImmune()

void Unit::ApplySpellImmune	(	uint32	spellId,
		uint32	op,
		uint32	type,
		bool	apply,
		SpellImmuneBlockType	blockType = `SPELL_BLOCK_TYPE_ALL`
	)

Definition at line 13293 of file Unit.cpp.

{
    if (apply)
    {
        // xinef: immunities with spellId 0 are intended to be applied only once (script purposes mosty)
        if (spellId == 0 && std::find_if(m_spellImmune[op].begin(), m_spellImmune[op].end(), spellIdImmunityPredicate(type)) != m_spellImmune[op].end())
            return;
 
        SpellImmune immune;
        immune.spellId = spellId;
        immune.type = type;
        immune.blockType = blockType;
        m_spellImmune[op].push_back(std::move(immune));
    }
    else
    {
        for (SpellImmuneList::iterator itr = m_spellImmune[op].begin(); itr != m_spellImmune[op].end(); ++itr)
        {
            if (itr->spellId == spellId && itr->type == type)
            {
                m_spellImmune[op].erase(itr);
                break;
            }
        }
    }
}

◆ ApplyStatBuffMod()

void Unit::ApplyStatBuffMod	(	Stats	stat,
		float	val,
		bool	apply
	)

inline

Definition at line 2031 of file Unit.h.

2031{ ApplyModSignedFloatValue((val > 0 ? static_cast<uint16>(UNIT_FIELD_POSSTAT0) + stat : static_cast<uint16>(UNIT_FIELD_NEGSTAT0) + stat), val, apply); }

UNIT_FIELD_POSSTAT0

@ UNIT_FIELD_POSSTAT0

Definition: UpdateFields.h:146

UNIT_FIELD_NEGSTAT0

@ UNIT_FIELD_NEGSTAT0

Definition: UpdateFields.h:151

◆ ApplyStatPercentBuffMod()

void Unit::ApplyStatPercentBuffMod	(	Stats	stat,
		float	val,
		bool	apply
	)

Definition at line 15194 of file Unit.cpp.

{
    if (val == -100.0f)     // prevent set var to zero
        val = -99.99f;
    float var = GetStat(stat) * val / 100.0f;
    ApplyModSignedFloatValue((var > 0 ? static_cast<uint16>(UNIT_FIELD_POSSTAT0) + stat : static_cast<uint16>(UNIT_FIELD_NEGSTAT0) + stat), var, apply);
}

◆ ApplyTotalThreatModifier()

float Unit::ApplyTotalThreatModifier	(	float	fThreat,
		SpellSchoolMask	schoolMask = `SPELL_SCHOOL_MASK_NORMAL`
	)

Definition at line 14511 of file Unit.cpp.

{
    if (!HasAuraType(SPELL_AURA_MOD_THREAT) || fThreat < 0)
        return fThreat;
 
    SpellSchools school = GetFirstSchoolInMask(schoolMask);
 
    return fThreat * m_threatModifier[school];
}

◆ Attack()

bool Unit::Attack	(	Unit *	victim,
		bool	meleeAttack
	)

Definition at line 10233 of file Unit.cpp.

{
    if (!victim || victim == this)
        return false;
 
    // dead units can neither attack nor be attacked
    if (!IsAlive() || !victim->IsAlive())
        return false;
 
    // pussywizard: check map, world, phase >_> multithreading crash fix
    if (!IsInMap(victim) || !InSamePhase(victim))
        return false;
 
    // player cannot attack in mount state
    if (GetTypeId() == TYPEID_PLAYER && IsMounted())
        return false;
 
    // creatures cannot attack while evading
    Creature* creature = ToCreature();
    if (creature && creature->IsInEvadeMode())
    {
        return false;
    }
 
    // creatures should not try to attack the player during polymorph
    if (creature && creature->IsPolymorphed())
    {
        return false;
    }
 
    //if (HasUnitFlag(UNIT_FLAG_PACIFIED)) // pussywizard: why having this flag prevents from entering combat? it should just prevent melee attack
    //    return false;
 
    // nobody can attack GM in GM-mode
    if (victim->GetTypeId() == TYPEID_PLAYER)
    {
        if (victim->ToPlayer()->IsGameMaster())
            return false;
    }
    else
    {
        if (victim->ToCreature()->IsEvadingAttacks())
            return false;
    }
 
    // Unit with SPELL_AURA_SPIRIT_OF_REDEMPTION can not attack
    if (HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
        return false;
 
    // remove SPELL_AURA_MOD_UNATTACKABLE at attack (in case non-interruptible spells stun aura applied also that not let attack)
    if (HasAuraType(SPELL_AURA_MOD_UNATTACKABLE))
        RemoveAurasByType(SPELL_AURA_MOD_UNATTACKABLE);
 
    if (m_attacking)
    {
        if (m_attacking == victim)
        {
            // switch to melee attack from ranged/magic
            if (meleeAttack)
            {
                if (!HasUnitState(UNIT_STATE_MELEE_ATTACKING))
                {
                    AddUnitState(UNIT_STATE_MELEE_ATTACKING);
                    SendMeleeAttackStart(victim);
                    return true;
                }
            }
            else if (HasUnitState(UNIT_STATE_MELEE_ATTACKING))
            {
                ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
                SendMeleeAttackStop(victim);
                return true;
            }
            return false;
        }
 
        // switch target
        InterruptSpell(CURRENT_MELEE_SPELL, true, true, true);
        if (!meleeAttack)
            ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
    }
 
    if (m_attacking)
        m_attacking->_removeAttacker(this);
 
    m_attacking = victim;
    m_attacking->_addAttacker(this);
 
    // Set our target
    SetTarget(victim->GetGUID());
 
    if (meleeAttack)
        AddUnitState(UNIT_STATE_MELEE_ATTACKING);
 
    // set position before any AI calls/assistance
    //if (GetTypeId() == TYPEID_UNIT)
    //    ToCreature()->SetCombatStartPosition(GetPositionX(), GetPositionY(), GetPositionZ());
    if (creature && !(IsControllableGuardian() && IsControlledByPlayer()))
    {
        // should not let player enter combat by right clicking target - doesn't helps
        SetInCombatWith(victim);
        if (victim->GetTypeId() == TYPEID_PLAYER)
            victim->SetInCombatWith(this);
        AddThreat(victim, 0.0f);
 
        creature->SendAIReaction(AI_REACTION_HOSTILE);
 
        creature->CallAssistance();
        creature->SetAssistanceTimer(sWorld->getIntConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_PERIOD));
 
        SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_NONE);
    }
 
    // delay offhand weapon attack to next attack time
    if (haveOffhandWeapon() && isAttackReady(OFF_ATTACK))
        setAttackTimer(OFF_ATTACK, ATTACK_DISPLAY_DELAY);
 
    if (meleeAttack)
        SendMeleeAttackStart(victim);
 
    return true;
}

◆ AttackerStateUpdate()

void Unit::AttackerStateUpdate	(	Unit *	victim,
		WeaponAttackType	attType = `BASE_ATTACK`,
		bool	extra = `false`,
		bool	ignoreCasting = `false`
	)

Definition at line 2515 of file Unit.cpp.

{
    if (HasUnitFlag(UNIT_FLAG_PACIFIED))
    {
        return;
    }
 
    if (HasUnitState(UNIT_STATE_CANNOT_AUTOATTACK) && !extra && !ignoreCasting)
    {
        return;
    }
 
    if (!victim->IsAlive())
        return;
 
    if ((attType == BASE_ATTACK || attType == OFF_ATTACK) && !IsWithinLOSInMap(victim))
        return;
 
    // CombatStart puts the target into stand state, so we need to cache sit state here to know if we should crit later
    const bool sittingVictim = victim->GetTypeId() == TYPEID_PLAYER && (victim->IsSitState() || victim->getStandState() == UNIT_STAND_STATE_SLEEP);
 
    CombatStart(victim);
    RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MELEE_ATTACK);
 
    if (attType != BASE_ATTACK && attType != OFF_ATTACK)
        return;                                             // ignore ranged case
 
    if (!extra && _lastExtraAttackSpell)
    {
        _lastExtraAttackSpell = 0;
    }
 
    bool meleeAttack = true;
 
    // melee attack spell casted at main hand attack only - no normal melee dmg dealt
    if (attType == BASE_ATTACK && m_currentSpells[CURRENT_MELEE_SPELL] && !extra)
    {
        meleeAttack = false; // The melee attack is replaced by the melee spell
 
        Spell* meleeSpell = m_currentSpells[CURRENT_MELEE_SPELL];
        SpellCastResult castResult = meleeSpell->CheckCast(false);
        if (castResult != SPELL_CAST_OK)
        {
            meleeSpell->SendCastResult(castResult);
            meleeSpell->SendInterrupted(0);
 
            meleeSpell->finish(false);
            meleeSpell->SetExecutedCurrently(false);
 
            if (castResult == SPELL_FAILED_NO_POWER)
            {
                // Not enough rage, do a regular melee attack instead
                meleeAttack = true;
            }
        }
        else
        {
            meleeSpell->cast(true);
        }
    }
    if (meleeAttack)
    {
        // attack can be redirected to another target
        victim = GetMeleeHitRedirectTarget(victim);
        CalcDamageInfo damageInfo;
        CalculateMeleeDamage(victim, &damageInfo, attType, sittingVictim);
 
        // Send log damage message to client
        for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
        {
            Unit::DealDamageMods(victim, damageInfo.damages[i].damage, &damageInfo.damages[i].absorb);
        }
 
        SendAttackStateUpdate(&damageInfo);
 
        //TriggerAurasProcOnEvent(damageInfo);
 
        _lastDamagedTargetGuid = victim->GetGUID();
 
        DealMeleeDamage(&damageInfo, true);
 
        DamageInfo dmgInfo(damageInfo);
        Unit::ProcDamageAndSpell(damageInfo.attacker, damageInfo.target, damageInfo.procAttacker, damageInfo.procVictim, damageInfo.procEx, dmgInfo.GetDamage(),
            damageInfo.attackType, nullptr, nullptr, -1, nullptr, &dmgInfo);
 
        if (GetTypeId() == TYPEID_PLAYER)
            LOG_DEBUG("entities.unit", "AttackerStateUpdate: (Player) {} attacked {} for {} dmg, absorbed {}, blocked {}, resisted {}.",
                                 GetGUID().ToString(), victim->GetGUID().ToString(), dmgInfo.GetDamage(), dmgInfo.GetAbsorb(), dmgInfo.GetBlock(), dmgInfo.GetResist());
        else
            LOG_DEBUG("entities.unit", "AttackerStateUpdate: (NPC) {} attacked {} for {} dmg, absorbed {}, blocked {}, resisted {}.",
                                 GetGUID().ToString(), victim->GetGUID().ToString(), dmgInfo.GetDamage(), dmgInfo.GetAbsorb(), dmgInfo.GetBlock(), dmgInfo.GetResist());
 
        // Let the pet know we've started attacking someting. Handles melee attacks only
        // Spells such as auto-shot and others handled in WorldSession::HandleCastSpellOpcode
        if (GetTypeId() == TYPEID_PLAYER && !m_Controlled.empty())
            for (Unit::ControlSet::iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
                if (Unit* pet = *itr)
                    if (pet->IsAlive() && pet->GetTypeId() == TYPEID_UNIT)
                        pet->ToCreature()->AI()->OwnerAttacked(victim);
    }
}

◆ AttackStop()

bool Unit::AttackStop ( )

Definition at line 10356 of file Unit.cpp.

{
    if (!m_attacking)
        return false;
 
    Unit* victim = m_attacking;
 
    m_attacking->_removeAttacker(this);
    m_attacking = nullptr;
 
    // Clear our target
    SetTarget(ObjectGuid::Empty);
 
    ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
 
    InterruptSpell(CURRENT_MELEE_SPELL);
 
    // reset only at real combat stop
    if (Creature* creature = ToCreature())
    {
        creature->SetNoCallAssistance(false);
 
        if (creature->HasSearchedAssistance())
        {
            creature->SetNoSearchAssistance(false);
        }
    }
 
    SendMeleeAttackStop(victim);
 
    return true;
}

◆ BuildAuraStateUpdateForTarget()

uint32 Unit::BuildAuraStateUpdateForTarget ( Unit * target ) const

Definition at line 10484 of file Unit.cpp.

{
    uint32 auraStates = GetUInt32Value(UNIT_FIELD_AURASTATE) & ~(PER_CASTER_AURA_STATE_MASK);
    for (AuraStateAurasMap::const_iterator itr = m_auraStateAuras.begin(); itr != m_auraStateAuras.end(); ++itr)
        if ((1 << (itr->first - 1)) & PER_CASTER_AURA_STATE_MASK)
            if (itr->second->GetBase()->GetCasterGUID() == target->GetGUID())
                auraStates |= (1 << (itr->first - 1));
 
    return auraStates;
}

◆ BuildCooldownPacket() [1/2]

void Unit::BuildCooldownPacket	(	WorldPacket &	data,
		uint8	flags,
		PacketCooldowns const &	cooldowns
	)

Definition at line 21010 of file Unit.cpp.

{
    data.Initialize(SMSG_SPELL_COOLDOWN, 8 + 1 + (4 + 4) * cooldowns.size());
    data << GetGUID();
    data << uint8(flags);
    for (std::unordered_map<uint32, uint32>::const_iterator itr = cooldowns.begin(); itr != cooldowns.end(); ++itr)
    {
        data << uint32(itr->first);
        data << uint32(itr->second);
    }
}

◆ BuildCooldownPacket() [2/2]

void Unit::BuildCooldownPacket	(	WorldPacket &	data,
		uint8	flags,
		uint32	spellId,
		uint32	cooldown
	)

Definition at line 21001 of file Unit.cpp.

{
    data.Initialize(SMSG_SPELL_COOLDOWN, 8 + 1 + 4 + 4);
    data << GetGUID();
    data << uint8(flags);
    data << uint32(spellId);
    data << uint32(cooldown);
}

◆ BuildHeartBeatMsg()

void Unit::BuildHeartBeatMsg ( WorldPacket * data ) const

Definition at line 2034 of file Object.cpp.

{
    data->Initialize(MSG_MOVE_HEARTBEAT, 32);
    *data << GetPackGUID();
    BuildMovementPacket(data);
}

◆ BuildMovementPacket()

void Unit::BuildMovementPacket ( ByteBuffer * data ) const

Definition at line 19910 of file Unit.cpp.

{
    *data << uint32(GetUnitMovementFlags());            // movement flags
    *data << uint16(GetExtraUnitMovementFlags());       // 2.3.0
    *data << uint32(GameTime::GetGameTimeMS().count());                       // time / counter
    *data << GetPositionX();
    *data << GetPositionY();
    *data << GetPositionZ();
    *data << GetOrientation();
 
    // 0x00000200
    if (GetUnitMovementFlags() & MOVEMENTFLAG_ONTRANSPORT)
    {
        if (m_vehicle)
            *data << m_vehicle->GetBase()->GetPackGUID();
        else if (GetTransport())
            *data << GetTransport()->GetPackGUID();
        else
            *data << (uint8)0;
 
        *data << float (GetTransOffsetX());
        *data << float (GetTransOffsetY());
        *data << float (GetTransOffsetZ());
        *data << float (GetTransOffsetO());
        *data << uint32(GetTransTime());
        *data << uint8 (GetTransSeat());
 
        if (GetExtraUnitMovementFlags() & MOVEMENTFLAG2_INTERPOLATED_MOVEMENT)
            *data << uint32(m_movementInfo.transport.time2);
    }
 
    // 0x02200000
    if ((GetUnitMovementFlags() & (MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_FLYING))
            || (m_movementInfo.flags2 & MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING))
        *data << (float)m_movementInfo.pitch;
 
    *data << (uint32)m_movementInfo.fallTime;
 
    // 0x00001000
    if (GetUnitMovementFlags() & MOVEMENTFLAG_FALLING)
    {
        *data << (float)m_movementInfo.jump.zspeed;
        *data << (float)m_movementInfo.jump.sinAngle;
        *data << (float)m_movementInfo.jump.cosAngle;
        *data << (float)m_movementInfo.jump.xyspeed;
    }
 
    // 0x04000000
    if (GetUnitMovementFlags() & MOVEMENTFLAG_SPLINE_ELEVATION)
        *data << (float)m_movementInfo.splineElevation;
}

◆ BuildValuesUpdate()

void Unit::BuildValuesUpdate	(	uint8	updatetype,
		ByteBuffer *	data,
		Player *	target
	)		const

overrideprotectedvirtual

Reimplemented from Object.

Definition at line 20792 of file Unit.cpp.

{
    if (!target)
        return;
 
    ByteBuffer fieldBuffer;
 
    UpdateMask updateMask;
    updateMask.SetCount(m_valuesCount);
 
    uint32* flags = UnitUpdateFieldFlags;
    uint32 visibleFlag = UF_FLAG_PUBLIC;
 
    if (target == this)
        visibleFlag |= UF_FLAG_PRIVATE;
 
    Player* plr = GetCharmerOrOwnerPlayerOrPlayerItself();
    if (GetOwnerGUID() == target->GetGUID())
        visibleFlag |= UF_FLAG_OWNER;
 
    if (HasDynamicFlag(UNIT_DYNFLAG_SPECIALINFO))
        if (HasAuraTypeWithCaster(SPELL_AURA_EMPATHY, target->GetGUID()))
            visibleFlag |= UF_FLAG_SPECIAL_INFO;
 
    if (plr && plr->IsInSameRaidWith(target))
        visibleFlag |= UF_FLAG_PARTY_MEMBER;
 
    Creature const* creature = ToCreature();
    for (uint16 index = 0; index < m_valuesCount; ++index)
    {
        if (_fieldNotifyFlags & flags[index] ||
                ((flags[index] & visibleFlag) & UF_FLAG_SPECIAL_INFO) ||
                ((updateType == UPDATETYPE_VALUES ? _changesMask.GetBit(index) : m_uint32Values[index]) && (flags[index] & visibleFlag)) ||
                (index == UNIT_FIELD_AURASTATE && HasFlag(UNIT_FIELD_AURASTATE, PER_CASTER_AURA_STATE_MASK)))
        {
            updateMask.SetBit(index);
 
            if (index == UNIT_NPC_FLAGS)
            {
                uint32 appendValue = m_uint32Values[UNIT_NPC_FLAGS];
 
                if (creature)
                {
                    if (sWorld->getIntConfig(CONFIG_INSTANT_TAXI) == 2 && appendValue & UNIT_NPC_FLAG_FLIGHTMASTER)
                    {
                        appendValue |= UNIT_NPC_FLAG_GOSSIP; // flight masters need NPC gossip flag to show instant flight toggle option
                    }
 
                    if (!target->CanSeeSpellClickOn(creature))
                    {
                        appendValue &= ~UNIT_NPC_FLAG_SPELLCLICK;
                    }
 
                    if (!target->CanSeeVendor(creature))
                    {
                        appendValue &= ~UNIT_NPC_FLAG_VENDOR_MASK;
                    }
 
                    if (!creature->IsValidTrainerForPlayer(target, &appendValue))
                    {
                        appendValue &= ~UNIT_NPC_FLAG_TRAINER;
                    }
                }
 
                fieldBuffer << uint32(appendValue);
            }
            else if (index == UNIT_FIELD_AURASTATE)
            {
                // Check per caster aura states to not enable using a spell in client if specified aura is not by target
                fieldBuffer << BuildAuraStateUpdateForTarget(target);
            }
            // FIXME: Some values at server stored in float format but must be sent to client in uint32 format
            else if (index >= UNIT_FIELD_BASEATTACKTIME && index <= UNIT_FIELD_RANGEDATTACKTIME)
            {
                // convert from float to uint32 and send
                fieldBuffer << uint32(m_floatValues[index] < 0 ? 0 : m_floatValues[index]);
            }
            // there are some float values which may be negative or can't get negative due to other checks
            else if ((index >= UNIT_FIELD_NEGSTAT0   && index <= UNIT_FIELD_NEGSTAT4) ||
                     (index >= UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE + 6)) ||
                     (index >= UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE  && index <= (UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE + 6)) ||
                     (index >= UNIT_FIELD_POSSTAT0   && index <= UNIT_FIELD_POSSTAT4))
            {
                fieldBuffer << uint32(m_floatValues[index]);
            }
            // Gamemasters should be always able to select units - remove not selectable flag
            else if (index == UNIT_FIELD_FLAGS)
            {
                uint32 appendValue = m_uint32Values[UNIT_FIELD_FLAGS];
                if (target->IsGameMaster() && AccountMgr::IsGMAccount(target->GetSession()->GetSecurity()))
                    appendValue &= ~UNIT_FLAG_NOT_SELECTABLE;
 
                fieldBuffer << uint32(appendValue);
            }
            // use modelid_a if not gm, _h if gm for CREATURE_FLAG_EXTRA_TRIGGER creatures
            else if (index == UNIT_FIELD_DISPLAYID)
            {
                uint32 displayId = m_uint32Values[UNIT_FIELD_DISPLAYID];
                if (creature)
                {
                    CreatureTemplate const* cinfo = creature->GetCreatureTemplate();
 
                    // this also applies for transform auras
                    if (SpellInfo const* transform = sSpellMgr->GetSpellInfo(getTransForm()))
                        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                            if (transform->Effects[i].IsAura(SPELL_AURA_TRANSFORM))
                                if (CreatureTemplate const* transformInfo = sObjectMgr->GetCreatureTemplate(transform->Effects[i].MiscValue))
                                {
                                    cinfo = transformInfo;
                                    break;
                                }
 
                    if (cinfo->flags_extra & CREATURE_FLAG_EXTRA_TRIGGER)
                    {
                        if (target->IsGameMaster() && AccountMgr::IsGMAccount(target->GetSession()->GetSecurity()))
                        {
                            if (cinfo->Modelid1)
                                displayId = cinfo->Modelid1;    // Modelid1 is a visible model for gms
                            else
                                displayId = 17519;              // world visible trigger's model
                        }
                        else
                        {
                            if (cinfo->Modelid2)
                                displayId = cinfo->Modelid2;    // Modelid2 is an invisible model for players
                            else
                                displayId = 11686;              // world invisible trigger's model
                        }
                    }
                }
 
                fieldBuffer << uint32(displayId);
            }
            // hide lootable animation for unallowed players
            else if (index == UNIT_DYNAMIC_FLAGS)
            {
                uint32 dynamicFlags = m_uint32Values[UNIT_DYNAMIC_FLAGS] & ~(UNIT_DYNFLAG_TAPPED | UNIT_DYNFLAG_TAPPED_BY_PLAYER);
 
                if (creature)
                {
                    if (creature->hasLootRecipient())
                    {
                        dynamicFlags |= UNIT_DYNFLAG_TAPPED;
                        if (creature->isTappedBy(target))
                            dynamicFlags |= UNIT_DYNFLAG_TAPPED_BY_PLAYER;
                    }
 
                    if (!target->isAllowedToLoot(creature))
                        dynamicFlags &= ~UNIT_DYNFLAG_LOOTABLE;
                }
 
                // unit UNIT_DYNFLAG_TRACK_UNIT should only be sent to caster of SPELL_AURA_MOD_STALKED auras
                if (dynamicFlags & UNIT_DYNFLAG_TRACK_UNIT)
                    if (!HasAuraTypeWithCaster(SPELL_AURA_MOD_STALKED, target->GetGUID()))
                        dynamicFlags &= ~UNIT_DYNFLAG_TRACK_UNIT;
 
                fieldBuffer << dynamicFlags;
            }
            // FG: pretend that OTHER players in own group are friendly ("blue")
            else if (index == UNIT_FIELD_BYTES_2 || index == UNIT_FIELD_FACTIONTEMPLATE)
            {
                if (IsControlledByPlayer() && target != this && sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP) && IsInRaidWith(target))
                {
                    FactionTemplateEntry const* ft1 = GetFactionTemplateEntry();
                    FactionTemplateEntry const* ft2 = target->GetFactionTemplateEntry();
                    if (ft1 && ft2 && !ft1->IsFriendlyTo(*ft2))
                    {
                        if (index == UNIT_FIELD_BYTES_2)
                            // Allow targetting opposite faction in party when enabled in config
                            fieldBuffer << (m_uint32Values[UNIT_FIELD_BYTES_2] & ((UNIT_BYTE2_FLAG_SANCTUARY /*| UNIT_BYTE2_FLAG_AURAS | UNIT_BYTE2_FLAG_UNK5*/) << 8)); // this flag is at uint8 offset 1 !!
                        else
                            // pretend that all other HOSTILE players have own faction, to allow follow, heal, rezz (trade wont work)
                            fieldBuffer << uint32(target->GetFaction());
                    }
                    else
                        fieldBuffer << m_uint32Values[index];
                }// pussywizard / Callmephil
                else if (target->IsSpectator() && target->FindMap() && target->FindMap()->IsBattleArena() &&
                         (this->GetTypeId() == TYPEID_PLAYER || this->GetTypeId() == TYPEID_UNIT || this->GetTypeId() == TYPEID_DYNAMICOBJECT))
                {
                    if (index == UNIT_FIELD_BYTES_2)
                        fieldBuffer << (m_uint32Values[index] & 0xFFFFF2FF); // clear UNIT_BYTE2_FLAG_PVP, UNIT_BYTE2_FLAG_FFA_PVP, UNIT_BYTE2_FLAG_SANCTUARY
                    else
                        fieldBuffer << (uint32)target->GetFaction();
                }
                else
                    if (!sScriptMgr->IsCustomBuildValuesUpdate(this, updateType, fieldBuffer, target, index))
                    {
                        fieldBuffer << m_uint32Values[index];
                    }
            }
            else
            {
                if (sScriptMgr->OnBuildValuesUpdate(this, updateType, fieldBuffer, target, index))
                {
                    continue;
                }
 
                // send in current format (float as float, uint32 as uint32)
                fieldBuffer << m_uint32Values[index];
            }
        }
    }
 
    *data << uint8(updateMask.GetBlockCount());
    updateMask.AppendToPacket(data);
    data->append(fieldBuffer);
}

◆ CalcAbsorbResist()

void Unit::CalcAbsorbResist	(	DamageInfo &	dmgInfo,
		bool	Splited = `false`
	)

static

Definition at line 2105 of file Unit.cpp.

{
    Unit* victim = dmgInfo.GetVictim();
    Unit* attacker = dmgInfo.GetAttacker();
    uint32 damage = dmgInfo.GetDamage();
    SpellSchoolMask schoolMask = dmgInfo.GetSchoolMask();
    SpellInfo const* spellInfo = dmgInfo.GetSpellInfo();
 
    if (!victim || !victim->IsAlive() || !damage)
        return;
 
    // Magic damage, check for resists
    // Ignore spells that cant be resisted
    // Xinef: holy resistance exists for npcs
    if (!(schoolMask & SPELL_SCHOOL_MASK_NORMAL) && (!(schoolMask & SPELL_SCHOOL_MASK_HOLY) || victim->GetTypeId() == TYPEID_UNIT) && (!spellInfo || (!spellInfo->HasAttribute(SPELL_ATTR0_CU_BINARY_SPELL) && !spellInfo->HasAttribute(SPELL_ATTR4_NO_CAST_LOG))))
    {
        float averageResist = Unit::GetEffectiveResistChance(attacker, schoolMask, victim);
 
        float discreteResistProbability[11];
        for (uint32 i = 0; i < 11; ++i)
        {
            discreteResistProbability[i] = 0.5f - 2.5f * std::fabs(0.1f * i - averageResist);
            if (discreteResistProbability[i] < 0.0f)
                discreteResistProbability[i] = 0.0f;
        }
 
        if (averageResist <= 0.1f)
        {
            discreteResistProbability[0] = 1.0f - 7.5f * averageResist;
            discreteResistProbability[1] = 5.0f * averageResist;
            discreteResistProbability[2] = 2.5f * averageResist;
        }
 
        float r = float(rand_norm());
        uint32 i = 0;
        float probabilitySum = discreteResistProbability[0];
 
        while (r >= probabilitySum && i < 10)
            probabilitySum += discreteResistProbability[++i];
 
        float damageResisted = float(damage * i / 10);
 
        if (damageResisted) // if equal to 0, checking these is pointless
        {
            if (attacker)
            {
                AuraEffectList const& ResIgnoreAurasAb = attacker->GetAuraEffectsByType(SPELL_AURA_MOD_ABILITY_IGNORE_TARGET_RESIST);
                for (AuraEffectList::const_iterator j = ResIgnoreAurasAb.begin(); j != ResIgnoreAurasAb.end(); ++j)
                    if (((*j)->GetMiscValue() & schoolMask) && (*j)->IsAffectedOnSpell(spellInfo))
                        AddPct(damageResisted, -(*j)->GetAmount());
 
                AuraEffectList const& ResIgnoreAuras = attacker->GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
                for (AuraEffectList::const_iterator j = ResIgnoreAuras.begin(); j != ResIgnoreAuras.end(); ++j)
                    if ((*j)->GetMiscValue() & schoolMask)
                        AddPct(damageResisted, -(*j)->GetAmount());
            }
 
            // pussywizard:
            if (spellInfo && spellInfo->HasAttribute(SPELL_ATTR0_CU_SCHOOLMASK_NORMAL_WITH_MAGIC))
            {
                uint32 damageAfterArmor = Unit::CalcArmorReducedDamage(attacker, victim, damage, spellInfo, 0, BASE_ATTACK);
                uint32 armorReduction = damage - damageAfterArmor;
                if (armorReduction < damageResisted) // pick the lower one, the weakest resistance counts
                    damageResisted = armorReduction;
            }
        }
 
        dmgInfo.ResistDamage(uint32(damageResisted));
    }
 
    // Ignore Absorption Auras
    float auraAbsorbMod = 0;
    if (attacker)
    {
        AuraEffectList const& AbsIgnoreAurasA = attacker->GetAuraEffectsByType(SPELL_AURA_MOD_TARGET_ABSORB_SCHOOL);
        for (AuraEffectList::const_iterator itr = AbsIgnoreAurasA.begin(); itr != AbsIgnoreAurasA.end(); ++itr)
        {
            if (!((*itr)->GetMiscValue() & schoolMask))
                continue;
 
            if ((*itr)->GetAmount() > auraAbsorbMod)
                auraAbsorbMod = float((*itr)->GetAmount());
        }
 
        AuraEffectList const& AbsIgnoreAurasB = attacker->GetAuraEffectsByType(SPELL_AURA_MOD_TARGET_ABILITY_ABSORB_SCHOOL);
        for (AuraEffectList::const_iterator itr = AbsIgnoreAurasB.begin(); itr != AbsIgnoreAurasB.end(); ++itr)
        {
            if (!((*itr)->GetMiscValue() & schoolMask))
                continue;
 
            if (((*itr)->GetAmount() > auraAbsorbMod) && (*itr)->IsAffectedOnSpell(spellInfo))
                auraAbsorbMod = float((*itr)->GetAmount());
        }
        RoundToInterval(auraAbsorbMod, 0.0f, 100.0f);
    }
 
    // We're going to call functions which can modify content of the list during iteration over it's elements
    // Let's copy the list so we can prevent iterator invalidation
    AuraEffectList vSchoolAbsorbCopy(victim->GetAuraEffectsByType(SPELL_AURA_SCHOOL_ABSORB));
    vSchoolAbsorbCopy.sort(Acore::AbsorbAuraOrderPred());
 
    // absorb without mana cost
    for (AuraEffectList::iterator itr = vSchoolAbsorbCopy.begin(); (itr != vSchoolAbsorbCopy.end()) && (dmgInfo.GetDamage() > 0); ++itr)
    {
        AuraEffect* absorbAurEff = *itr;
        // Check if aura was removed during iteration - we don't need to work on such auras
        AuraApplication const* aurApp = absorbAurEff->GetBase()->GetApplicationOfTarget(victim->GetGUID());
        if (!aurApp)
            continue;
        if (!(absorbAurEff->GetMiscValue() & schoolMask))
            continue;
 
        // get amount which can be still absorbed by the aura
        int32 currentAbsorb = absorbAurEff->GetAmount();
        // aura with infinite absorb amount - let the scripts handle absorbtion amount, set here to 0 for safety
        if (currentAbsorb < 0)
            currentAbsorb = 0;
 
        uint32 tempAbsorb = uint32(currentAbsorb);
 
        bool defaultPrevented = false;
 
        absorbAurEff->GetBase()->CallScriptEffectAbsorbHandlers(absorbAurEff, aurApp, dmgInfo, tempAbsorb, defaultPrevented);
        currentAbsorb = tempAbsorb;
 
        if (defaultPrevented)
            continue;
 
        // absorb must be smaller than the damage itself
        currentAbsorb = RoundToInterval(currentAbsorb, 0, int32(dmgInfo.GetDamage()));
 
        // xinef: do this after absorb is rounded to damage...
        AddPct(currentAbsorb, -auraAbsorbMod);
 
        dmgInfo.AbsorbDamage(currentAbsorb);
 
        tempAbsorb = currentAbsorb;
        absorbAurEff->GetBase()->CallScriptEffectAfterAbsorbHandlers(absorbAurEff, aurApp, dmgInfo, tempAbsorb);
 
        // Check if our aura is using amount to count damage
        if (absorbAurEff->GetAmount() >= 0)
        {
            // Reduce shield amount
            absorbAurEff->SetAmount(absorbAurEff->GetAmount() - currentAbsorb);
            // Aura cannot absorb anything more - remove it
            if (absorbAurEff->GetAmount() <= 0)
                absorbAurEff->GetBase()->Remove(AURA_REMOVE_BY_ENEMY_SPELL);
        }
    }
 
    // absorb by mana cost
    AuraEffectList vManaShieldCopy(victim->GetAuraEffectsByType(SPELL_AURA_MANA_SHIELD));
    for (AuraEffectList::const_iterator itr = vManaShieldCopy.begin(); (itr != vManaShieldCopy.end()) && (dmgInfo.GetDamage() > 0); ++itr)
    {
        AuraEffect* absorbAurEff = *itr;
        // Check if aura was removed during iteration - we don't need to work on such auras
        AuraApplication const* aurApp = absorbAurEff->GetBase()->GetApplicationOfTarget(victim->GetGUID());
        if (!aurApp)
            continue;
        // check damage school mask
        if (!(absorbAurEff->GetMiscValue() & schoolMask))
            continue;
 
        // get amount which can be still absorbed by the aura
        int32 currentAbsorb = absorbAurEff->GetAmount();
        // aura with infinite absorb amount - let the scripts handle absorbtion amount, set here to 0 for safety
        if (currentAbsorb < 0)
            currentAbsorb = 0;
 
        uint32 tempAbsorb = currentAbsorb;
 
        bool defaultPrevented = false;
 
        absorbAurEff->GetBase()->CallScriptEffectManaShieldHandlers(absorbAurEff, aurApp, dmgInfo, tempAbsorb, defaultPrevented);
        currentAbsorb = tempAbsorb;
 
        if (defaultPrevented)
            continue;
 
        // absorb must be smaller than the damage itself
        currentAbsorb = RoundToInterval(currentAbsorb, 0, int32(dmgInfo.GetDamage()));
 
        // xinef: do this after absorb is rounded to damage...
        AddPct(currentAbsorb, -auraAbsorbMod);
 
        int32 manaReduction = currentAbsorb;
 
        // lower absorb amount by talents
        if (float manaMultiplier = absorbAurEff->GetSpellInfo()->Effects[absorbAurEff->GetEffIndex()].CalcValueMultiplier(absorbAurEff->GetCaster()))
            manaReduction = int32(float(manaReduction) * manaMultiplier);
 
        int32 manaTaken = -victim->ModifyPower(POWER_MANA, -manaReduction);
 
        // take case when mana has ended up into account
        currentAbsorb = currentAbsorb ? int32(float(currentAbsorb) * (float(manaTaken) / float(manaReduction))) : 0;
 
        dmgInfo.AbsorbDamage(currentAbsorb);
 
        tempAbsorb = currentAbsorb;
        absorbAurEff->GetBase()->CallScriptEffectAfterManaShieldHandlers(absorbAurEff, aurApp, dmgInfo, tempAbsorb);
 
        // Check if our aura is using amount to count damage
        if (absorbAurEff->GetAmount() >= 0)
        {
            absorbAurEff->SetAmount(absorbAurEff->GetAmount() - currentAbsorb);
            if ((absorbAurEff->GetAmount() <= 0))
                absorbAurEff->GetBase()->Remove(AURA_REMOVE_BY_ENEMY_SPELL);
        }
    }
 
    // split damage auras - only when not damaging self
    // Xinef: not true - Warlock Hellfire
    if (/*victim != attacker &&*/ !Splited)
    {
        // We're going to call functions which can modify content of the list during iteration over it's elements
        // Let's copy the list so we can prevent iterator invalidation
        AuraEffectList vSplitDamageFlatCopy(victim->GetAuraEffectsByType(SPELL_AURA_SPLIT_DAMAGE_FLAT));
        for (AuraEffectList::iterator itr = vSplitDamageFlatCopy.begin(); (itr != vSplitDamageFlatCopy.end()) && (dmgInfo.GetDamage() > 0); ++itr)
        {
            // Check if aura was removed during iteration - we don't need to work on such auras
            if (!((*itr)->GetBase()->IsAppliedOnTarget(victim->GetGUID())))
                continue;
            // check damage school mask
            if (!((*itr)->GetMiscValue() & schoolMask))
                continue;
 
            // Damage can be splitted only if aura has an alive caster
            Unit* caster = (*itr)->GetCaster();
            if (!caster || (caster == victim) || !caster->IsInWorld() || !caster->IsAlive())
                continue;
 
            int32 splitDamage = (*itr)->GetAmount();
 
            // absorb must be smaller than the damage itself
            splitDamage = RoundToInterval(splitDamage, 0, int32(dmgInfo.GetDamage()));
 
            dmgInfo.AbsorbDamage(splitDamage);
 
            uint32 splitted = splitDamage;
            uint32 splitted_absorb = 0;
            uint32 splitted_resist = 0;
 
            uint32 procAttacker = 0, procVictim = 0, procEx = PROC_EX_NORMAL_HIT;
            DamageInfo splittedDmgInfo(attacker, caster, splitted, spellInfo, schoolMask, dmgInfo.GetDamageType());
            if (caster->IsImmunedToDamageOrSchool(schoolMask))
            {
                procEx |= PROC_EX_IMMUNE;
                splittedDmgInfo.AbsorbDamage(splitted);
            }
            else
            {
                Unit::CalcAbsorbResist(splittedDmgInfo, true);
                Unit::DealDamageMods(caster, splitted, &splitted_absorb);
            }
 
            splitted_absorb = splittedDmgInfo.GetAbsorb();
            splitted_resist = splittedDmgInfo.GetResist();
            splitted = splittedDmgInfo.GetDamage();
 
            // create procs
            createProcFlags(spellInfo, BASE_ATTACK, false, procAttacker, procVictim);
            caster->ProcDamageAndSpellFor(true, attacker, procVictim, procEx, BASE_ATTACK, spellInfo, splitted, nullptr, -1, nullptr, &splittedDmgInfo);
 
            if (attacker)
            {
                attacker->SendSpellNonMeleeDamageLog(caster, (*itr)->GetSpellInfo(), splitted, schoolMask, splitted_absorb, splitted_resist, false, 0, false, true);
            }
 
            CleanDamage cleanDamage = CleanDamage(splitted, 0, BASE_ATTACK, MELEE_HIT_NORMAL);
            Unit::DealDamage(attacker, caster, splitted, &cleanDamage, DIRECT_DAMAGE, schoolMask, (*itr)->GetSpellInfo(), false);
        }
 
        // We're going to call functions which can modify content of the list during iteration over it's elements
        // Let's copy the list so we can prevent iterator invalidation
        AuraEffectList vSplitDamagePctCopy(victim->GetAuraEffectsByType(SPELL_AURA_SPLIT_DAMAGE_PCT));
        for (AuraEffectList::iterator itr = vSplitDamagePctCopy.begin(), next; (itr != vSplitDamagePctCopy.end()) &&  (dmgInfo.GetDamage() > 0); ++itr)
        {
            // Check if aura was removed during iteration - we don't need to work on such auras
            AuraApplication const* aurApp = (*itr)->GetBase()->GetApplicationOfTarget(victim->GetGUID());
            if (!aurApp)
                continue;
 
            // check damage school mask
            if (!((*itr)->GetMiscValue() & schoolMask))
                continue;
 
            // Damage can be splitted only if aura has an alive caster
            Unit* caster = (*itr)->GetCaster();
            if (!caster || (caster == victim) || !caster->IsInWorld() || !caster->IsAlive())
                continue;
 
            // Xinef: Single Target splits require LoS
            SpellInfo const* splitSpellInfo = (*itr)->GetSpellInfo();
            if (!splitSpellInfo->Effects[(*itr)->GetEffIndex()].IsAreaAuraEffect() && !splitSpellInfo->HasAttribute(SPELL_ATTR2_IGNORE_LINE_OF_SIGHT))
                if (!caster->IsWithinLOSInMap(victim) || !caster->IsWithinDist(victim, splitSpellInfo->GetMaxRange(splitSpellInfo->IsPositive(), caster)))
                    continue;
 
            uint32 splitDamage = CalculatePct(dmgInfo.GetDamage(), (*itr)->GetAmount());
            SpellSchoolMask splitSchoolMask  = schoolMask;
 
            (*itr)->GetBase()->CallScriptEffectSplitHandlers(*itr, aurApp, dmgInfo, splitDamage);
 
            // absorb must be smaller than the damage itself
            splitDamage = RoundToInterval(splitDamage, uint32(0), uint32(dmgInfo.GetDamage()));
 
            // Roar of Sacrifice, dont absorb it
            if (splitSpellInfo->Id != 53480)
                dmgInfo.AbsorbDamage(splitDamage);
            else
                splitSchoolMask = SPELL_SCHOOL_MASK_NATURE;
 
            uint32 splitted = splitDamage;
            uint32 splitted_absorb = 0;
            uint32 splitted_resist = 0;
 
            uint32 procAttacker = 0, procVictim = 0, procEx = PROC_EX_NORMAL_HIT;
            DamageInfo splittedDmgInfo(attacker, caster, splitted, spellInfo, splitSchoolMask, dmgInfo.GetDamageType());
            if (caster->IsImmunedToDamageOrSchool(schoolMask))
            {
                procEx |= PROC_EX_IMMUNE;
                splittedDmgInfo.AbsorbDamage(splitted);
            }
            else
            {
                Unit::CalcAbsorbResist(splittedDmgInfo, true);
                Unit::DealDamageMods(caster, splitted, &splitted_absorb);
            }
 
            splitted_absorb = splittedDmgInfo.GetAbsorb();
            splitted_resist = splittedDmgInfo.GetResist();
            splitted = splittedDmgInfo.GetDamage();
 
            // create procs
            createProcFlags(spellInfo, BASE_ATTACK, false, procAttacker, procVictim);
            caster->ProcDamageAndSpellFor(true, attacker, procVictim, procEx, BASE_ATTACK, spellInfo, splitted);
 
            if (attacker)
            {
                attacker->SendSpellNonMeleeDamageLog(caster, splitSpellInfo, splitted, splitSchoolMask, splitted_absorb, splitted_resist, false, 0, false, true);
            }
 
            CleanDamage cleanDamage = CleanDamage(splitted, 0, BASE_ATTACK, MELEE_HIT_NORMAL);
            Unit::DealDamage(attacker, caster, splitted, &cleanDamage, DIRECT_DAMAGE, splitSchoolMask, splitSpellInfo, false);
        }
    }
}

◆ CalcArmorReducedDamage()

uint32 Unit::CalcArmorReducedDamage	(	Unit const *	attacker,
		Unit const *	victim,
		const uint32	damage,
		SpellInfo const *	spellInfo,
		uint8	attackerLevel = `0`,
		WeaponAttackType	attackType = `MAX_ATTACK`
	)

static

Definition at line 1989 of file Unit.cpp.

{
    float armor = float(victim->GetArmor());
 
    // Ignore enemy armor by SPELL_AURA_MOD_TARGET_RESISTANCE aura
    if (attacker)
    {
        armor += attacker->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, SPELL_SCHOOL_MASK_NORMAL);
 
        if (spellInfo)
            if (Player* modOwner = attacker->GetSpellModOwner())
                modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_IGNORE_ARMOR, armor);
 
        AuraEffectList const& ResIgnoreAurasAb = attacker->GetAuraEffectsByType(SPELL_AURA_MOD_ABILITY_IGNORE_TARGET_RESIST);
        for (AuraEffectList::const_iterator j = ResIgnoreAurasAb.begin(); j != ResIgnoreAurasAb.end(); ++j)
        {
            if ((*j)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL
                    && (*j)->IsAffectedOnSpell(spellInfo))
                armor = floor(AddPct(armor, -(*j)->GetAmount()));
        }
 
        AuraEffectList const& ResIgnoreAuras = attacker->GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
        for (AuraEffectList::const_iterator j = ResIgnoreAuras.begin(); j != ResIgnoreAuras.end(); ++j)
        {
            if ((*j)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
                armor = floor(AddPct(armor, -(*j)->GetAmount()));
        }
 
        // Apply Player CR_ARMOR_PENETRATION rating and buffs from stances\specializations etc.
        if (attacker->GetTypeId() == TYPEID_PLAYER)
        {
            float bonusPct = 0;
            AuraEffectList const& armorPenAuras = attacker->GetAuraEffectsByType(SPELL_AURA_MOD_ARMOR_PENETRATION_PCT);
            for (AuraEffectList::const_iterator itr = armorPenAuras.begin(); itr != armorPenAuras.end(); ++itr)
            {
                if ((*itr)->GetSpellInfo()->EquippedItemClass == -1)
                {
                    if (!spellInfo || (*itr)->IsAffectedOnSpell(spellInfo) || (*itr)->GetMiscValue() & spellInfo->GetSchoolMask())
                        bonusPct += (*itr)->GetAmount();
                    else if (!(*itr)->GetMiscValue() && !(*itr)->HasSpellClassMask())
                        bonusPct += (*itr)->GetAmount();
                }
                else
                {
                    if (attacker->ToPlayer()->HasItemFitToSpellRequirements((*itr)->GetSpellInfo()))
                        bonusPct += (*itr)->GetAmount();
                }
            }
 
            float maxArmorPen = 0;
            if (victim->getLevel() < 60)
                maxArmorPen = float(400 + 85 * victim->getLevel());
            else
                maxArmorPen = 400 + 85 * victim->getLevel() + 4.5f * 85 * (victim->getLevel() - 59);
 
            // Cap armor penetration to this number
            maxArmorPen = std::min((armor + maxArmorPen) / 3, armor);
            // Figure out how much armor do we ignore
            float armorPen = CalculatePct(maxArmorPen, bonusPct + attacker->ToPlayer()->GetRatingBonusValue(CR_ARMOR_PENETRATION));
            // Got the value, apply it
            armor -= std::min(armorPen, maxArmorPen);
        }
    }
 
    if (armor < 0.0f)
        armor = 0.0f;
 
    float levelModifier = attacker ? attacker->getLevel() : attackerLevel;
    if (levelModifier > 59)
        levelModifier = levelModifier + (4.5f * (levelModifier - 59));
 
    float tmpvalue = 0.1f * armor / (8.5f * levelModifier + 40);
    tmpvalue = tmpvalue / (1.0f + tmpvalue);
 
    if (tmpvalue < 0.0f)
        tmpvalue = 0.0f;
    if (tmpvalue > 0.75f)
        tmpvalue = 0.75f;
 
    return uint32(std::ceil(std::max(damage * (1.0f - tmpvalue), 0.0f)));
}

◆ CalcHealAbsorb()

void Unit::CalcHealAbsorb ( HealInfo & healInfo )

static

Definition at line 2452 of file Unit.cpp.

{
    if (!healInfo.GetHeal())
        return;
 
    int32 const healing = static_cast<int32>(healInfo.GetHeal());
    int32 absorbAmount = 0;
 
    // Need remove expired auras after
    bool existExpired = false;
 
    // absorb without mana cost
    AuraEffectList const& vHealAbsorb = healInfo.GetTarget()->GetAuraEffectsByType(SPELL_AURA_SCHOOL_HEAL_ABSORB);
    for (AuraEffectList::const_iterator i = vHealAbsorb.begin(); i != vHealAbsorb.end() && absorbAmount <= healing; ++i)
    {
        if (!((*i)->GetMiscValue() & healInfo.GetSpellInfo()->SchoolMask))
            continue;
 
        // Max Amount can be absorbed by this aura
        int32 currentAbsorb = (*i)->GetAmount();
 
        // Found empty aura (impossible but..)
        if (currentAbsorb <= 0)
        {
            existExpired = true;
            continue;
        }
 
        // currentAbsorb - damage can be absorbed by shield
        // If need absorb less damage
        if (healing < currentAbsorb + absorbAmount)
            currentAbsorb = healing - absorbAmount;
 
        absorbAmount += currentAbsorb;
 
        // Reduce shield amount
        (*i)->SetAmount((*i)->GetAmount() - currentAbsorb);
        // Need remove it later
        if ((*i)->GetAmount() <= 0)
            existExpired = true;
    }
 
    // Remove all expired absorb auras
    if (existExpired)
    {
        for (AuraEffectList::const_iterator i = vHealAbsorb.begin(); i != vHealAbsorb.end();)
        {
            AuraEffect* auraEff = *i;
            ++i;
            if (auraEff->GetAmount() <= 0)
            {
                uint32 removedAuras = healInfo.GetTarget()->m_removedAurasCount;
                auraEff->GetBase()->Remove(AURA_REMOVE_BY_ENEMY_SPELL);
                if (removedAuras + 1 < healInfo.GetTarget()->m_removedAurasCount)
                    i = vHealAbsorb.begin();
            }
        }
    }
 
    if (absorbAmount > 0)
        healInfo.AbsorbHeal(absorbAmount);
}

◆ CalcSpellDuration()

int32 Unit::CalcSpellDuration ( SpellInfo const * spellProto )

Definition at line 14713 of file Unit.cpp.

{
    uint8 comboPoints = GetComboPoints();
 
    int32 minduration = spellProto->GetDuration();
    int32 maxduration = spellProto->GetMaxDuration();
 
    int32 duration;
 
    if (comboPoints && minduration != -1 && minduration != maxduration)
        duration = minduration + int32((maxduration - minduration) * comboPoints / 5);
    else
        duration = minduration;
 
    return duration;
}

◆ CalculateAOEDamageReduction()

int32 Unit::CalculateAOEDamageReduction	(	int32	damage,
		uint32	schoolMask,
		Unit *	caster
	)		const

Definition at line 20476 of file Unit.cpp.

{
    damage = int32(float(damage) * GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_AOE_DAMAGE_AVOIDANCE, schoolMask));
    if (caster && caster->GetTypeId() == TYPEID_UNIT)
        damage = int32(float(damage) * GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CREATURE_AOE_DAMAGE_AVOIDANCE, schoolMask));
 
    return damage;
}

◆ CalculateDamage()

uint32 Unit::CalculateDamage	(	WeaponAttackType	attType,
		bool	normalized,
		bool	addTotalPct,
		uint8	itemDamagesMask = `0`
	)

Definition at line 2934 of file Unit.cpp.

{
    float minDamage = 0.0f;
    float maxDamage = 0.0f;
 
    if (normalized || !addTotalPct || itemDamagesMask)
    {
        // get both by default
        if (!itemDamagesMask)
        {
            itemDamagesMask = (1 << 0) | (1 << 1);
        }
 
        for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
        {
            if (itemDamagesMask & (1 << i))
            {
                float minTmp, maxTmp;
                CalculateMinMaxDamage(attType, normalized, addTotalPct, minTmp, maxTmp, i);
                minDamage += minTmp;
                maxDamage += maxTmp;
            }
        }
    }
    else
    {
        switch (attType)
        {
            case RANGED_ATTACK:
                minDamage = GetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE);
                maxDamage = GetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE);
                break;
            case BASE_ATTACK:
                minDamage = GetFloatValue(UNIT_FIELD_MINDAMAGE);
                maxDamage = GetFloatValue(UNIT_FIELD_MAXDAMAGE);
                break;
            case OFF_ATTACK:
                minDamage = GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE);
                maxDamage = GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE);
                break;
            default:
                break;
        }
    }
 
    minDamage = std::max(0.f, minDamage);
    maxDamage = std::max(0.f, maxDamage);
 
    if (minDamage > maxDamage)
    {
        std::swap(minDamage, maxDamage);
    }
 
    return urand(uint32(minDamage), uint32(maxDamage));
}

◆ CalculateDefaultCoefficient()

float Unit::CalculateDefaultCoefficient	(	SpellInfo const *	spellInfo,
		DamageEffectType	damagetype
	)		const

Definition at line 17257 of file Unit.cpp.

{
    // Damage over Time spells bonus calculation
    float DotFactor = 1.0f;
    if (damagetype == DOT)
    {
        int32 DotDuration = spellInfo->GetDuration();
        if (!spellInfo->IsChanneled() && DotDuration > 0)
            DotFactor = DotDuration / 15000.0f;
 
        if (uint32 DotTicks = spellInfo->GetMaxTicks())
            DotFactor /= DotTicks;
    }
 
    int32 CastingTime = spellInfo->IsChanneled() ? spellInfo->GetDuration() : spellInfo->CalcCastTime();
    // Distribute Damage over multiple effects, reduce by AoE
    CastingTime = GetCastingTimeForBonus(spellInfo, damagetype, CastingTime);
 
    // As wowwiki says: C = (Cast Time / 3.5)
    return (CastingTime / 3500.0f) * DotFactor;
}

◆ CalculateLevelPenalty()

float Unit::CalculateLevelPenalty ( SpellInfo const * spellProto ) const

Definition at line 2990 of file Unit.cpp.

{
    if (GetTypeId() != TYPEID_PLAYER)
        return 1.0f;
 
    if (spellProto->SpellLevel <= 0 || spellProto->SpellLevel >= spellProto->MaxLevel)
        return 1.0f;
 
    float LvlPenalty = 0.0f;
 
    // xinef: added brackets
    if (spellProto->SpellLevel < 20)
        LvlPenalty = (20.0f - spellProto->SpellLevel) * 3.75f;
 
    float LvlFactor = (float(spellProto->SpellLevel) + 6.0f) / float(getLevel());
    if (LvlFactor > 1.0f)
        LvlFactor = 1.0f;
 
    return AddPct(LvlFactor, -LvlPenalty);
}

◆ CalculateMeleeDamage()

void Unit::CalculateMeleeDamage	(	Unit *	victim,
		CalcDamageInfo *	damageInfo,
		WeaponAttackType	attackType = `BASE_ATTACK`,
		const bool	sittingVictim = `false`
	)

Definition at line 1460 of file Unit.cpp.

{
    damageInfo->attacker         = this;
    damageInfo->target           = victim;
 
    for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
    {
        damageInfo->damages[i].damageSchoolMask = GetMeleeDamageSchoolMask(attackType, i);
        damageInfo->damages[i].damage = 0;
        damageInfo->damages[i].absorb = 0;
        damageInfo->damages[i].resist = 0;
    }
 
    damageInfo->attackType       = attackType;
    damageInfo->cleanDamage      = 0;
    damageInfo->blocked_amount   = 0;
 
    damageInfo->TargetState      = 0;
    damageInfo->HitInfo          = 0;
    damageInfo->procAttacker     = PROC_FLAG_NONE;
    damageInfo->procVictim       = PROC_FLAG_NONE;
    damageInfo->procEx           = PROC_EX_NONE;
    damageInfo->hitOutCome       = MELEE_HIT_EVADE;
 
    if (!victim)
        return;
 
    if (!IsAlive() || !victim->IsAlive())
        return;
 
    // Select HitInfo/procAttacker/procVictim flag based on attack type
    switch (attackType)
    {
        case BASE_ATTACK:
            damageInfo->procAttacker = PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_DONE_MAINHAND_ATTACK;
            damageInfo->procVictim   = PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK;
            break;
        case OFF_ATTACK:
            damageInfo->procAttacker = PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_DONE_OFFHAND_ATTACK;
            damageInfo->procVictim   = PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK;
            damageInfo->HitInfo      = HITINFO_OFFHAND;
            break;
        default:
            return;
    }
 
    // School Immune check
    uint8 immunedMask = 0;
    bool hasNonPhysicalSchoolMask = false;
    for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
    {
        if (damageInfo->target->IsImmunedToDamageOrSchool(SpellSchoolMask(damageInfo->damages[i].damageSchoolMask)))
        {
            immunedMask |= (1 << i);
            if (damageInfo->damages[i].damageSchoolMask != SPELL_SCHOOL_MASK_NORMAL)
            {
                hasNonPhysicalSchoolMask = true;
            }
        }
    }
 
    // School Immune check
    if (immunedMask & ((1 << 0) | (1 << 1)))
    {
        if (hasNonPhysicalSchoolMask || immunedMask == ((1 << 0) | (1 << 1)))
        {
            damageInfo->HitInfo |= HITINFO_NORMALSWING;
            damageInfo->TargetState = VICTIMSTATE_IS_IMMUNE;
 
            damageInfo->procEx |= PROC_EX_IMMUNE;
            return;
        }
    }
 
    for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
    {
        // only players have secondary weapon damage
        if (i > 0 && GetTypeId() != TYPEID_PLAYER)
        {
            break;
        }
 
        if (immunedMask & (1 << i))
        {
            continue;
        }
 
        SpellSchoolMask schoolMask = SpellSchoolMask(damageInfo->damages[i].damageSchoolMask);
        bool const addPctMods = (schoolMask & SPELL_SCHOOL_MASK_NORMAL);
 
        uint32 damage = 0;
        uint8 itemDamagesMask = (GetTypeId() == TYPEID_PLAYER) ? (1 << i) : 0;
 
        damage += CalculateDamage(damageInfo->attackType, false, addPctMods, itemDamagesMask);
        // Add melee damage bonus
        damage = MeleeDamageBonusDone(damageInfo->target, damage, damageInfo->attackType, nullptr, schoolMask);
        damage = damageInfo->target->MeleeDamageBonusTaken(this, damage, damageInfo->attackType, nullptr, schoolMask);
 
        // Script Hook For CalculateMeleeDamage -- Allow scripts to change the Damage pre class mitigation calculations
        sScriptMgr->ModifyMeleeDamage(damageInfo->target, damageInfo->attacker, damage);
 
        // Calculate armor reduction
        if (IsDamageReducedByArmor((SpellSchoolMask)(damageInfo->damages[i].damageSchoolMask)))
        {
            damageInfo->damages[i].damage = Unit::CalcArmorReducedDamage(this, damageInfo->target, damage, nullptr, 0, damageInfo->attackType);
            damageInfo->cleanDamage += damage - damageInfo->damages[i].damage;
        }
        else
        {
            damageInfo->damages[i].damage = damage;
        }
    }
 
    damageInfo->hitOutCome = RollMeleeOutcomeAgainst(damageInfo->target, damageInfo->attackType);
 
    // If the victim was a sitting player and we didn't roll a miss, then crit.
    if (sittingVictim && damageInfo->hitOutCome != MELEE_HIT_MISS)
    {
        damageInfo->hitOutCome = MELEE_HIT_CRIT;
    }
    switch (damageInfo->hitOutCome)
    {
        case MELEE_HIT_EVADE:
            damageInfo->HitInfo        |= HITINFO_MISS | HITINFO_SWINGNOHITSOUND;
            damageInfo->TargetState     = VICTIMSTATE_EVADES;
            damageInfo->procEx         |= PROC_EX_EVADE;
 
            for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
            {
                damageInfo->damages[i].damage = 0;
            }
 
            damageInfo->cleanDamage = 0;
            return;
        case MELEE_HIT_MISS:
            damageInfo->HitInfo        |= HITINFO_MISS;
            damageInfo->TargetState     = VICTIMSTATE_INTACT;
            damageInfo->procEx         |= PROC_EX_MISS;
 
            for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
            {
                damageInfo->damages[i].damage = 0;
            }
            damageInfo->cleanDamage     = 0;
            break;
        case MELEE_HIT_NORMAL:
            damageInfo->TargetState     = VICTIMSTATE_HIT;
            damageInfo->procEx         |= PROC_EX_NORMAL_HIT;
            break;
        case MELEE_HIT_CRIT:
            {
                damageInfo->HitInfo        |= HITINFO_CRITICALHIT;
                damageInfo->TargetState     = VICTIMSTATE_HIT;
 
                damageInfo->procEx         |= PROC_EX_CRITICAL_HIT;
                // Crit bonus calc
                for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
                {
                    damageInfo->damages[i].damage *= 2;
 
                    float mod = 0.0f;
                    // Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
                    if (damageInfo->attackType == RANGED_ATTACK)
                    {
                        mod += damageInfo->target->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
                    }
                    else
                    {
                        mod += damageInfo->target->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
 
                        // Increase crit damage from SPELL_AURA_MOD_CRIT_DAMAGE_BONUS
                        mod += (GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS, damageInfo->damages[i].damageSchoolMask) - 1.0f) * 100;
                    }
 
                    uint32 crTypeMask = damageInfo->target->GetCreatureTypeMask();
 
                    // Increase crit damage from SPELL_AURA_MOD_CRIT_PERCENT_VERSUS
                    mod += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, crTypeMask);
                    if (mod != 0)
                    {
                        AddPct(damageInfo->damages[i].damage, mod);
                    }
                }
                break;
            }
        case MELEE_HIT_PARRY:
            damageInfo->TargetState  = VICTIMSTATE_PARRY;
            damageInfo->procEx      |= PROC_EX_PARRY;
            damageInfo->cleanDamage = 0;
 
            for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
            {
                damageInfo->cleanDamage += damageInfo->damages[i].damage;
                damageInfo->damages[i].damage = 0;
            }
            break;
        case MELEE_HIT_DODGE:
            damageInfo->TargetState  = VICTIMSTATE_DODGE;
            damageInfo->procEx      |= PROC_EX_DODGE;
            damageInfo->cleanDamage = 0;
 
            for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
            {
                damageInfo->cleanDamage += damageInfo->damages[i].damage;
                damageInfo->damages[i].damage = 0;
            }
            break;
        case MELEE_HIT_BLOCK:
        {
            damageInfo->TargetState = VICTIMSTATE_HIT;
            damageInfo->HitInfo |= HITINFO_BLOCK;
            damageInfo->procEx |= PROC_EX_BLOCK;
            damageInfo->blocked_amount = damageInfo->target->GetShieldBlockValue();
            // double blocked amount if block is critical
            if (damageInfo->target->isBlockCritical())
                damageInfo->blocked_amount += damageInfo->blocked_amount;
 
            uint32 remainingBlock = damageInfo->blocked_amount;
            uint8 fullBlockMask = 0;
            for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
            {
                if (remainingBlock && remainingBlock >= damageInfo->damages[i].damage)
                {
                    fullBlockMask |= (1 << i);
 
                    remainingBlock -= damageInfo->damages[i].damage;
                    damageInfo->cleanDamage += damageInfo->damages[i].damage;
                    damageInfo->damages[i].damage = 0;
                }
                else
                {
                    damageInfo->cleanDamage += remainingBlock;
                    damageInfo->damages[i].damage -= remainingBlock;
                    remainingBlock = 0;
                }
            }
 
            // full block
            if (fullBlockMask == ((1 << 0) | (1 << 1)))
            {
                damageInfo->TargetState = VICTIMSTATE_BLOCKS;
                damageInfo->blocked_amount -= remainingBlock;
            }
            break;
        }
        case MELEE_HIT_GLANCING:
        {
            damageInfo->HitInfo     |= HITINFO_GLANCING;
            damageInfo->TargetState  = VICTIMSTATE_HIT;
            damageInfo->procEx      |= PROC_EX_NORMAL_HIT;
            int32 leveldif = int32(victim->getLevel()) - int32(getLevel());
            if (leveldif > 3)
                leveldif = 3;
            float reducePercent = 1 - leveldif * 0.1f;
 
            for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
            {
                uint32 reducedDamage = uint32(reducePercent * damageInfo->damages[i].damage);
                damageInfo->cleanDamage += damageInfo->damages[i].damage - reducedDamage;
                damageInfo->damages[i].damage = reducedDamage;
            }
            break;
        }
        case MELEE_HIT_CRUSHING:
            damageInfo->HitInfo     |= HITINFO_CRUSHING;
            damageInfo->TargetState  = VICTIMSTATE_HIT;
            damageInfo->procEx      |= PROC_EX_NORMAL_HIT;
 
            // 150% normal damage
            for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
            {
                damageInfo->damages[i].damage += (damageInfo->damages[i].damage / 2);
            }
            break;
        default:
            break;
    }
 
    // Always apply HITINFO_AFFECTS_VICTIM in case its not a miss
    if (!(damageInfo->HitInfo & HITINFO_MISS))
        damageInfo->HitInfo |= HITINFO_AFFECTS_VICTIM;
 
    uint32 tmpHitInfo[MAX_ITEM_PROTO_DAMAGES] = { };
 
    for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
    {
        int32 dmg = damageInfo->damages[i].damage;
        int32 cleanDamage = damageInfo->cleanDamage;
        // attackType is checked already for BASE_ATTACK or OFF_ATTACK so it can't be RANGED_ATTACK here
        if (CanApplyResilience())
        {
            int32 resilienceReduction = damageInfo->damages[i].damage;
            Unit::ApplyResilience(victim, nullptr, &resilienceReduction, (damageInfo->hitOutCome == MELEE_HIT_CRIT), CR_CRIT_TAKEN_MELEE);
 
            resilienceReduction = damageInfo->damages[i].damage - resilienceReduction;
            dmg -= resilienceReduction;
            cleanDamage += resilienceReduction;
        }
 
        damageInfo->damages[i].damage = std::max(0, dmg);
        damageInfo->cleanDamage = std::max(0, cleanDamage);
 
        // Calculate absorb resist
        if (damageInfo->damages[i].damage > 0)
        {
            damageInfo->procVictim |= PROC_FLAG_TAKEN_DAMAGE;
 
            // Calculate absorb & resists
            DamageInfo dmgInfo(*damageInfo, i);
            Unit::CalcAbsorbResist(dmgInfo);
            damageInfo->damages[i].absorb = dmgInfo.GetAbsorb();
            damageInfo->damages[i].resist = dmgInfo.GetResist();
 
            if (damageInfo->damages[i].absorb)
            {
                tmpHitInfo[i] |= (damageInfo->damages[i].damage - damageInfo->damages[i].absorb == 0 ? HITINFO_FULL_ABSORB : HITINFO_PARTIAL_ABSORB);
            }
 
            if (damageInfo->damages[i].resist)
            {
                tmpHitInfo[i] |= (damageInfo->damages[i].damage - damageInfo->damages[i].resist == 0 ? HITINFO_FULL_RESIST : HITINFO_PARTIAL_RESIST);
            }
 
            damageInfo->damages[i].damage = dmgInfo.GetDamage();
        }
    }
 
    // set proper HitInfo flags
    if ((tmpHitInfo[0] & HITINFO_FULL_ABSORB) != 0)
    {
        // set partial absorb when secondary damage isn't full absorbed
        damageInfo->HitInfo |= ((tmpHitInfo[1] & HITINFO_PARTIAL_ABSORB) != 0) ? HITINFO_PARTIAL_ABSORB : HITINFO_FULL_ABSORB;
    }
    else
    {
        damageInfo->HitInfo |= (tmpHitInfo[0] & HITINFO_PARTIAL_ABSORB);
    }
 
    if ((tmpHitInfo[0] & HITINFO_FULL_RESIST) != 0)
    {
        // set partial resist when secondary damage isn't full resisted
        damageInfo->HitInfo |= ((tmpHitInfo[1] & HITINFO_PARTIAL_RESIST) != 0) ? HITINFO_PARTIAL_RESIST : HITINFO_FULL_RESIST;
    }
    else
    {
        damageInfo->HitInfo |= (tmpHitInfo[0] & HITINFO_PARTIAL_RESIST);
    }
}

◆ CalculateMinMaxDamage()

virtual void Unit::CalculateMinMaxDamage	(	WeaponAttackType	attType,
		bool	normalized,
		bool	addTotalPct,
		float &	minDamage,
		float &	maxDamage,
		uint8	damageIndex = `0`
	)

pure virtual

Implemented in Creature, and Player.

◆ CalculateSpellDamage()

int32 Unit::CalculateSpellDamage	(	Unit const *	target,
		SpellInfo const *	spellProto,
		uint8	effect_index,
		int32 const *	basePoints = `nullptr`
	)		const

Definition at line 14708 of file Unit.cpp.

{
    return spellProto->Effects[effect_index].CalcValue(this, basePoints, target);
}

◆ CalculateSpellDamageTaken()

void Unit::CalculateSpellDamageTaken	(	SpellNonMeleeDamage *	damageInfo,
		int32	damage,
		SpellInfo const *	spellInfo,
		WeaponAttackType	attackType = `BASE_ATTACK`,
		bool	crit = `false`
	)

Definition at line 1296 of file Unit.cpp.

{
    if (damage < 0)
        return;
 
    Unit* victim = damageInfo->target;
    if (!victim || !victim->IsAlive())
        return;
 
    SpellSchoolMask damageSchoolMask = SpellSchoolMask(damageInfo->schoolMask);
    uint32 crTypeMask = victim->GetCreatureTypeMask();
 
     // Script Hook For CalculateSpellDamageTaken -- Allow scripts to change the Damage post class mitigation calculations
    sScriptMgr->ModifySpellDamageTaken(damageInfo->target, damageInfo->attacker, damage, spellInfo);
 
    int32 cleanDamage = 0;
    if (Unit::IsDamageReducedByArmor(damageSchoolMask, spellInfo))
    {
        int32 oldDamage = damage;
        damage = Unit::CalcArmorReducedDamage(this, victim, damage, spellInfo, 0, attackType);
        cleanDamage = oldDamage - damage;
    }
 
    bool blocked = false;
    // Per-school calc
    switch (spellInfo->DmgClass)
    {
        // Melee and Ranged Spells
        case SPELL_DAMAGE_CLASS_RANGED:
        case SPELL_DAMAGE_CLASS_MELEE:
            {
                // Physical Damage
                if (damageSchoolMask & SPELL_SCHOOL_MASK_NORMAL)
                {
                    // Get blocked status
                    blocked = isSpellBlocked(victim, spellInfo, attackType);
                }
 
                if (crit)
                {
                    damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
 
                    // Calculate crit bonus
                    uint32 crit_bonus = damage;
                    // Apply crit_damage bonus for melee spells
                    if (Player* modOwner = GetSpellModOwner())
                        modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
                    damage += crit_bonus;
 
                    // Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
                    float critPctDamageMod = 0.0f;
                    if (attackType == RANGED_ATTACK)
                        critPctDamageMod += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
                    else
                        critPctDamageMod += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
 
                    // Increase crit damage from SPELL_AURA_MOD_CRIT_DAMAGE_BONUS
                    critPctDamageMod += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS, spellInfo->GetSchoolMask());
 
                    // Increase crit damage from SPELL_AURA_MOD_CRIT_PERCENT_VERSUS
                    critPctDamageMod += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, crTypeMask);
 
                    if (critPctDamageMod != 0)
                        AddPct(damage, critPctDamageMod);
                }
 
                // Spell weapon based damage CAN BE crit & blocked at same time
                if (blocked)
                {
                    damageInfo->blocked = victim->GetShieldBlockValue();
                    // double blocked amount if block is critical
                    if (victim->isBlockCritical())
                        damageInfo->blocked *= 2;
                    if (damage < int32(damageInfo->blocked))
                        damageInfo->blocked = uint32(damage);
 
                    damage -= damageInfo->blocked;
                    cleanDamage += damageInfo->blocked;
                }
 
                int32 resilienceReduction = damage;
                if (CanApplyResilience())
                {
                    if (attackType != RANGED_ATTACK)
                    {
                        Unit::ApplyResilience(victim, nullptr, &resilienceReduction, crit, CR_CRIT_TAKEN_MELEE);
                    }
                    else
                    {
                        Unit::ApplyResilience(victim, nullptr, &resilienceReduction, crit, CR_CRIT_TAKEN_RANGED);
                    }
                }
 
                resilienceReduction = damage - resilienceReduction;
                damage -= resilienceReduction;
                cleanDamage += resilienceReduction;
                break;
            }
        // Magical Attacks
        case SPELL_DAMAGE_CLASS_NONE:
        case SPELL_DAMAGE_CLASS_MAGIC:
            {
                // If crit add critical bonus
                if (crit)
                {
                    damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
                    damage = Unit::SpellCriticalDamageBonus(this, spellInfo, damage, victim);
                }
 
                int32 resilienceReduction = damage;
                if (CanApplyResilience())
                {
                    Unit::ApplyResilience(victim, nullptr, &resilienceReduction, crit, CR_CRIT_TAKEN_SPELL);
                }
 
                resilienceReduction = damage - resilienceReduction;
                damage -= resilienceReduction;
                cleanDamage += resilienceReduction;
                break;
            }
        default:
            break;
    }
 
    damageInfo->cleanDamage = std::max(0, cleanDamage);
    damageInfo->damage = std::max(0, damage);
 
    // Calculate absorb resist
    if (damageInfo->damage > 0)
    {
        DamageInfo dmgInfo(*damageInfo, SPELL_DIRECT_DAMAGE);
        Unit::CalcAbsorbResist(dmgInfo);
        damageInfo->absorb = dmgInfo.GetAbsorb();
        damageInfo->resist = dmgInfo.GetResist();
        damageInfo->damage = dmgInfo.GetDamage();
    }
}

◆ CanApplyResilience()

bool Unit::CanApplyResilience ( ) const

inline

Definition at line 2422 of file Unit.h.

2422{ return m_applyResilience; }

◆ CanDualWield()

bool Unit::CanDualWield ( ) const

inline

Definition at line 1345 of file Unit.h.

1345{ return m_canDualWield; }

◆ CanEnterWater()

virtual bool Unit::CanEnterWater ( ) const

pure virtual

Implemented in Creature, and Player.

◆ CanFly()

virtual bool Unit::CanFly ( ) const

pure virtual

Implemented in Creature, and Player.

◆ CanFreeMove()

bool Unit::CanFreeMove ( ) const

inline

Definition at line 1401 of file Unit.h.

    {
        return !HasUnitState(UNIT_STATE_CONFUSED | UNIT_STATE_FLEEING | UNIT_STATE_IN_FLIGHT |
                             UNIT_STATE_ROOT | UNIT_STATE_STUNNED | UNIT_STATE_DISTRACTED) && !GetOwnerGUID();
    }

◆ CanHaveThreatList()

bool Unit::CanHaveThreatList ( ) const

Definition at line 14484 of file Unit.cpp.

{
    // only creatures can have threat list
    if (GetTypeId() != TYPEID_UNIT)
        return false;
 
    // only alive units can have threat list
    if (!IsAlive() || isDying())
        return false;
 
    // totems can not have threat list
    if (ToCreature()->IsTotem())
        return false;
 
    // vehicles can not have threat list
    if (ToCreature()->IsVehicle() && GetMap()->IsBattlegroundOrArena())
        return false;
 
    // summons can not have a threat list, unless they are controlled by a creature
    if (HasUnitTypeMask(UNIT_MASK_MINION | UNIT_MASK_GUARDIAN | UNIT_MASK_CONTROLABLE_GUARDIAN) && ((Pet*)this)->GetOwnerGUID().IsPlayer())
        return false;
 
    return true;
}

◆ CanInstantCast()

bool Unit::CanInstantCast ( ) const

inline

Definition at line 2432 of file Unit.h.

2432{ return _instantCast; }

◆ CanModifyStats()

bool Unit::CanModifyStats ( ) const

inline

Definition at line 2102 of file Unit.h.

2102{ return m_canModifyStats; }

◆ CanProc()

bool Unit::CanProc ( )

inline

Definition at line 2315 of file Unit.h.

2315{return !m_procDeep;}

◆ CanRestoreMana()

bool Unit::CanRestoreMana ( SpellInfo const * spellInfo ) const

Definition at line 21220 of file Unit.cpp.

{
    // Aura of Despair exceptions
    switch (spellInfo->Id)
    {
        case 30824: // Shamanistic Rage
        case 31786: // Spiritual Attunement
        case 31930: // Judgements of the Wise
        case 34075: // Aspect of the Viper
        case 34720: // Thrill of the hunt
        case 47755: // Rapture
        case 63337: // Saronite Vapors (regenerate mana)
        case 63375: // Improved stormstrike
        case 64372: // Lifebloom
            return true;
        case 54428: // Divine Plea - only with talent Guarded by the Light
            return HasSpell(53583);
        default:
            break;
    }
 
    return false;
}

◆ CanSwim()

bool Unit::CanSwim ( ) const

virtual

this method checks the current flag of a unit

These flags can be set within the database or dynamically changed at runtime UNIT_FLAG_SWIMMING must be updated when a unit enters a swimmable area

Reimplemented in Creature.

Definition at line 19974 of file Unit.cpp.

{
    // Mirror client behavior, if this method returns false then client will not use swimming animation and for players will apply gravity as if there was no water
    if (HasUnitFlag(UNIT_FLAG_CANNOT_SWIM))
        return false;
    if (HasUnitFlag(UNIT_FLAG_POSSESSED)) // is player
        return true;
    if (HasUnitFlag2(UNIT_FLAG2_UNUSED_6))
        return false;
    if (HasUnitFlag(UNIT_FLAG_PET_IN_COMBAT))
        return true;
    return HasUnitFlag(UNIT_FLAG_RENAME | UNIT_FLAG_SWIMMING);
}

◆ CanUseAttackType()

bool Unit::CanUseAttackType ( uint8 attacktype ) const

inline

Definition at line 1604 of file Unit.h.

    {
        switch (attacktype)
        {
            case BASE_ATTACK:
                return !HasUnitFlag(UNIT_FLAG_DISARMED);
            case OFF_ATTACK:
                return !HasUnitFlag2(UNIT_FLAG2_DISARM_OFFHAND);
            case RANGED_ATTACK:
                return !HasUnitFlag2(UNIT_FLAG2_DISARM_RANGED);
        }
        return true;
    }

◆ CastCustomSpell() [1/4]

SpellCastResult Unit::CastCustomSpell	(	uint32	spellId,
		CustomSpellValues const &	value,
		Unit *	victim = `nullptr`,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1251 of file Unit.cpp.

{
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
    {
        LOG_ERROR("entities.unit", "CastSpell: unknown spell {} by caster {}", spellId, GetGUID().ToString());
        return SPELL_FAILED_SPELL_UNAVAILABLE;
    }
 
    SpellCastTargets targets;
    targets.SetUnitTarget(victim);
 
    return CastSpell(targets, spellInfo, &value, triggerFlags, castItem, triggeredByAura, originalCaster);
}

◆ CastCustomSpell() [2/4]

SpellCastResult Unit::CastCustomSpell	(	uint32	spellId,
		SpellValueMod	mod,
		int32	value,
		Unit *	victim,
		bool	triggered,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1237 of file Unit.cpp.

{
    CustomSpellValues values;
    values.AddSpellMod(mod, value);
    return CastCustomSpell(spellId, values, target, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
}

◆ CastCustomSpell() [3/4]

SpellCastResult Unit::CastCustomSpell	(	uint32	spellId,
		SpellValueMod	mod,
		int32	value,
		Unit *	victim = `nullptr`,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1244 of file Unit.cpp.

{
    CustomSpellValues values;
    values.AddSpellMod(mod, value);
    return CastCustomSpell(spellId, values, target, triggerFlags, castItem, triggeredByAura, originalCaster);
}

◆ CastCustomSpell() [4/4]

SpellCastResult Unit::CastCustomSpell	(	Unit *	victim,
		uint32	spellId,
		int32 const *	bp0,
		int32 const *	bp1,
		int32 const *	bp2,
		bool	triggered,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1225 of file Unit.cpp.

{
    CustomSpellValues values;
    if (bp0)
        values.AddSpellMod(SPELLVALUE_BASE_POINT0, *bp0);
    if (bp1)
        values.AddSpellMod(SPELLVALUE_BASE_POINT1, *bp1);
    if (bp2)
        values.AddSpellMod(SPELLVALUE_BASE_POINT2, *bp2);
    return CastCustomSpell(spellId, values, target, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
}

◆ CastDelayedSpellWithPeriodicAmount()

void Unit::CastDelayedSpellWithPeriodicAmount	(	Unit *	caster,
		uint32	spellId,
		AuraType	auraType,
		int32	addAmount,
		uint8	effectIndex = `0`
	)

Definition at line 20297 of file Unit.cpp.

{
    for (AuraEffectList::iterator i = m_modAuras[auraType].begin(); i != m_modAuras[auraType].end(); ++i)
    {
        AuraEffect* aurEff = *i;
        if (aurEff->GetCasterGUID() != caster->GetGUID() || aurEff->GetId() != spellId || aurEff->GetEffIndex() != effectIndex || !aurEff->GetTotalTicks())
            continue;
 
        addAmount += ((aurEff->GetOldAmount() * std::max<int32>(aurEff->GetTotalTicks() - int32(aurEff->GetTickNumber()), 0)) / aurEff->GetTotalTicks());
        break;
    }
 
    // xinef: delay only for casting on different unit
    if (this == caster)
        caster->CastCustomSpell(spellId, SPELLVALUE_BASE_POINT0, addAmount, this, TriggerCastFlags(TRIGGERED_FULL_MASK & ~TRIGGERED_NO_PERIODIC_RESET), nullptr, nullptr, caster->GetGUID());
    else
        caster->m_Events.AddEvent(new AuraMunchingQueue(*caster, GetGUID(), addAmount, spellId), caster->m_Events.CalculateQueueTime(400));
}

◆ CastPetAura()

void Unit::CastPetAura ( PetAura const * aura )

Definition at line 17371 of file Unit.cpp.

{
    uint32 auraId = aura->GetAura(GetEntry());
    if (!auraId)
        return;
 
    if (auraId == 35696)                                      // Demonic Knowledge
    {
        int32 basePoints = aura->GetDamage();
        CastCustomSpell(this, auraId, &basePoints, nullptr, nullptr, true);
    }
    else
        CastSpell(this, auraId, true);
}

◆ CastSpell() [1/7]

SpellCastResult Unit::CastSpell	(	float	x,
		float	y,
		float	z,
		uint32	spellId,
		bool	triggered,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1266 of file Unit.cpp.

{
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
    {
        LOG_ERROR("entities.unit", "CastSpell: unknown spell {} by caster {}", spellId, GetGUID().ToString());
        return SPELL_FAILED_SPELL_UNAVAILABLE;
    }
 
    SpellCastTargets targets;
    targets.SetDst(x, y, z, GetOrientation());
 
    return CastSpell(targets, spellInfo, nullptr, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
}

◆ CastSpell() [2/7]

SpellCastResult Unit::CastSpell	(	GameObject *	go,
		uint32	spellId,
		bool	triggered,
		Item *	castItem = `nullptr`,
		AuraEffect *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1281 of file Unit.cpp.

{
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
    {
        LOG_ERROR("entities.unit", "CastSpell: unknown spell {} by caster {}", spellId, GetGUID().ToString());
        return SPELL_FAILED_SPELL_UNAVAILABLE;
    }
 
    SpellCastTargets targets;
    targets.SetGOTarget(go);
 
    return CastSpell(targets, spellInfo, nullptr, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
}

◆ CastSpell() [3/7]

SpellCastResult Unit::CastSpell	(	SpellCastTargets const &	targets,
		SpellInfo const *	spellInfo,
		CustomSpellValues const *	value,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1168 of file Unit.cpp.

{
    if (!spellInfo)
    {
        LOG_ERROR("entities.unit", "CastSpell: unknown spell by caster {}", GetGUID().ToString());
        return SPELL_FAILED_SPELL_UNAVAILABLE;
    }
 
    // TODO: this is a workaround - not needed anymore, but required for some scripts :(
    if (!originalCaster && triggeredByAura)
    {
        originalCaster = triggeredByAura->GetCasterGUID();
    }
 
    Spell* spell = new Spell(this, spellInfo, triggerFlags, originalCaster);
 
    if (value)
    {
        for (CustomSpellValues::const_iterator itr = value->begin(); itr != value->end(); ++itr)
        {
            spell->SetSpellValue(itr->first, itr->second);
        }
    }
 
    spell->m_CastItem = castItem;
    return spell->prepare(&targets, triggeredByAura);
}

◆ CastSpell() [4/7]

SpellCastResult Unit::CastSpell	(	Unit *	victim,
		SpellInfo const *	spellInfo,
		bool	triggered,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1213 of file Unit.cpp.

{
    return CastSpell(victim, spellInfo, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
}

◆ CastSpell() [5/7]

SpellCastResult Unit::CastSpell	(	Unit *	victim,
		SpellInfo const *	spellInfo,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1218 of file Unit.cpp.

{
    SpellCastTargets targets;
    targets.SetUnitTarget(victim);
    return CastSpell(targets, spellInfo, nullptr, triggerFlags, castItem, triggeredByAura, originalCaster);
}

◆ CastSpell() [6/7]

SpellCastResult Unit::CastSpell	(	Unit *	victim,
		uint32	spellId,
		bool	triggered,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1196 of file Unit.cpp.

{
    return CastSpell(victim, spellId, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE, castItem, triggeredByAura, originalCaster);
}

◆ CastSpell() [7/7]

SpellCastResult Unit::CastSpell	(	Unit *	victim,
		uint32	spellId,
		TriggerCastFlags	triggerFlags = `TRIGGERED_NONE`,
		Item *	castItem = `nullptr`,
		AuraEffect const *	triggeredByAura = `nullptr`,
		ObjectGuid	originalCaster = `ObjectGuid::Empty`
	)

Definition at line 1201 of file Unit.cpp.

{
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
    {
        LOG_ERROR("entities.unit", "CastSpell: unknown spell {} by caster {}", spellId, GetGUID().ToString());
        return SPELL_FAILED_SPELL_UNAVAILABLE;
    }
 
    return CastSpell(victim, spellInfo, triggerFlags, castItem, triggeredByAura, originalCaster);
}

◆ CastStop()

void Unit::CastStop	(	uint32	except_spellid = `0`,
		bool	withInstant = `true`
	)

Definition at line 1161 of file Unit.cpp.

{
    for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; i++)
        if (m_currentSpells[i] && m_currentSpells[i]->m_spellInfo->Id != except_spellid)
            InterruptSpell(CurrentSpellTypes(i), false, withInstant);
}

◆ ChangeSeat()

void Unit::ChangeSeat	(	int8	seatId,
		bool	next = `true`
	)

Definition at line 19730 of file Unit.cpp.

{
    if (!m_vehicle)
        return;
 
    if (seatId < 0)
    {
        seatId = m_vehicle->GetNextEmptySeat(GetTransSeat(), next);
        if (seatId < 0)
            return;
    }
    else if (seatId == GetTransSeat() || !m_vehicle->HasEmptySeat(seatId))
        return;
 
    m_vehicle->RemovePassenger(this);
    if (!m_vehicle->AddPassenger(this, seatId))
        ABORT();
}

◆ CleanupBeforeRemoveFromMap()

void Unit::CleanupBeforeRemoveFromMap ( bool finalCleanup )

Definition at line 15579 of file Unit.cpp.

{
    if (IsDuringRemoveFromWorld())
        return;
 
    // This needs to be before RemoveFromWorld to make GetCaster() return a valid pointer on aura removal
    InterruptNonMeleeSpells(true);
 
    if (IsInWorld()) // not in world and not being removed atm
        RemoveFromWorld();
 
    ASSERT(GetGUID());
 
    // A unit may be in removelist and not in world, but it is still in grid
    // and may have some references during delete
    RemoveAllAuras();
    RemoveAllGameObjects();
 
    if (finalCleanup)
        m_cleanupDone = true;
 
    m_Events.KillAllEvents(false);                      // non-delatable (currently casted spells) will not deleted now but it will deleted at call in Map::RemoveAllObjectsInRemoveList
    CombatStop();
    ClearComboPoints();
    ClearComboPointHolders();
    GetThreatMgr().ClearAllThreat();
    getHostileRefMgr().deleteReferences();
    GetMotionMaster()->Clear(false);                    // remove different non-standard movement generators.
}

◆ CleanupsBeforeDelete()

void Unit::CleanupsBeforeDelete ( bool finalCleanup = true )

overridevirtual

Reimplemented from WorldObject.

Definition at line 15609 of file Unit.cpp.

{
    if (GetTransport())
    {
        GetTransport()->RemovePassenger(this);
        SetTransport(nullptr);
        m_movementInfo.transport.Reset();
        m_movementInfo.RemoveMovementFlag(MOVEMENTFLAG_ONTRANSPORT);
    }
 
    CleanupBeforeRemoveFromMap(finalCleanup);
}

◆ ClearAllReactives()

void Unit::ClearAllReactives ( )

Definition at line 16988 of file Unit.cpp.

{
    for (uint8 i = 0; i < MAX_REACTIVE; ++i)
        m_reactiveTimer[i] = 0;
 
    if (HasAuraState(AURA_STATE_DEFENSE))
        ModifyAuraState(AURA_STATE_DEFENSE, false);
    if (getClass() == CLASS_HUNTER && HasAuraState(AURA_STATE_HUNTER_PARRY))
        ModifyAuraState(AURA_STATE_HUNTER_PARRY, false);
    if (getClass() == CLASS_WARRIOR && GetTypeId() == TYPEID_PLAYER)
        ClearComboPoints();
}

◆ ClearComboPointHolders()

void Unit::ClearComboPointHolders ( )

Definition at line 16980 of file Unit.cpp.

{
    while (!m_ComboPointHolders.empty())
    {
        (*m_ComboPointHolders.begin())->ClearComboPoints(); // this also removes it from m_comboPointHolders
    }
}

◆ ClearComboPoints()

void Unit::ClearComboPoints ( )

Definition at line 16925 of file Unit.cpp.

{
    if (!m_comboTarget)
    {
        return;
    }
 
    // remove Premed-like effects
    // (NB: this Aura retains the CP while it's active - now that CP have reset, it shouldn't be there anymore)
    RemoveAurasByType(SPELL_AURA_RETAIN_COMBO_POINTS);
 
    m_comboPoints = 0;
    SendComboPoints();
    m_comboTarget->RemoveComboPointHolder(this);
    m_comboTarget = nullptr;
}

◆ ClearDiminishings()

void Unit::ClearDiminishings ( )

inline

Definition at line 1332 of file Unit.h.

1332{ m_Diminishing.clear(); }

◆ ClearInCombat()

void Unit::ClearInCombat ( )

Definition at line 13702 of file Unit.cpp.

{
    m_CombatTimer = 0;
    RemoveUnitFlag(UNIT_FLAG_IN_COMBAT);
 
    // Player's state will be cleared in Player::UpdateContestedPvP
    if (Creature* creature = ToCreature())
    {
        if (creature->GetCreatureTemplate() && creature->GetCreatureTemplate()->unit_flags & UNIT_FLAG_IMMUNE_TO_PC)
            SetImmuneToPC(true); // set immunity state to the one from db on evade
 
        ClearUnitState(UNIT_STATE_ATTACK_PLAYER);
        if (HasDynamicFlag(UNIT_DYNFLAG_TAPPED))
            ReplaceAllDynamicFlags(creature->GetCreatureTemplate()->dynamicflags);
 
        creature->SetAssistanceTimer(0);
 
        // Xinef: will be recalculated at follow movement generator initialization
        if (!IsPet() && !IsCharmed())
            return;
    }
    else if (Player* player = ToPlayer())
    {
        player->UpdatePotionCooldown();
        if (player->getClass() == CLASS_DEATH_KNIGHT)
            for (uint8 i = 0; i < MAX_RUNES; ++i)
                player->SetGracePeriod(i, 0);
    }
 
    if (Player* player = this->ToPlayer())
    {
        sScriptMgr->OnPlayerLeaveCombat(player);
    }
}

◆ ClearInPetCombat()

void Unit::ClearInPetCombat ( )

Definition at line 13737 of file Unit.cpp.

{
    RemoveUnitFlag(UNIT_FLAG_PET_IN_COMBAT);
    RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_LEAVE_COMBAT);
    if (Unit* owner = GetOwner())
    {
        owner->RemoveUnitFlag(UNIT_FLAG_PET_IN_COMBAT);
    }
}

◆ ClearUnitState()

void Unit::ClearUnitState ( uint32 f )

inline

Definition at line 1399 of file Unit.h.

1399{ m_state &= ~f; }

◆ CombatStart()

void Unit::CombatStart	(	Unit *	target,
		bool	initialAggro = `true`
	)

Definition at line 13529 of file Unit.cpp.

{
    // Xinef: Dont allow to start combat with triggers
    if (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsTrigger())
        return;
 
    if (initialAggro)
    {
        // Make player victim stand up automatically
        if (victim->getStandState() && victim->IsPlayer())
        {
            victim->SetStandState(UNIT_STAND_STATE_STAND);
        }
 
        if (!victim->IsInCombat() && victim->GetTypeId() != TYPEID_PLAYER && !victim->ToCreature()->HasReactState(REACT_PASSIVE) && victim->ToCreature()->IsAIEnabled)
        {
            if (victim->IsPet())
                victim->ToCreature()->AI()->AttackedBy(this); // PetAI has special handler before AttackStart()
            else
            {
                victim->ToCreature()->AI()->AttackStart(this);
                // if the target is an NPC with a pet or minion, pet should react.
                if (Unit* victimControlledUnit = victim->GetFirstControlled())
                {
                    victimControlledUnit->SetInCombatWith(this);
                    SetInCombatWith(victimControlledUnit);
                    victimControlledUnit->AddThreat(this, 0.0f);
                }
            }
 
            // if unit has an owner, put owner in combat.
            if (Unit* victimOwner = victim->GetOwner())
            {
                if (!(victimOwner->IsInCombatWith(this)))
                {
                    /* warding off to not take over aggro for no reason
                    Using only AddThreat causes delay in attack */
                    if (!victimOwner->IsInCombat() && victimOwner->IsAIEnabled)
                    {
                        victimOwner->ToCreature()->AI()->AttackStart(this);
                    }
                    victimOwner->SetInCombatWith(this);
                    SetInCombatWith(victimOwner);
                    victimOwner->AddThreat(this, 0.0f);
                }
            }
        }
 
        SetInCombatWith(victim);
        victim->SetInCombatWith(this);
 
        // Xinef: If pet started combat - put owner in combat
        if (Unit* owner = GetOwner())
        {
            owner->SetInCombatWith(victim);
            victim->SetInCombatWith(owner);
        }
    }
 
    Unit* who = victim->GetCharmerOrOwnerOrSelf();
    if (who->GetTypeId() == TYPEID_PLAYER)
        SetContestedPvP(who->ToPlayer());
 
    Player* player = GetCharmerOrOwnerPlayerOrPlayerItself();
    if (player && who->IsPvP() && (who->GetTypeId() != TYPEID_PLAYER || !player->duel || player->duel->Opponent != who))
    {
        player->UpdatePvP(true);
        player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
    }
}

◆ CombatStartOnCast()

void Unit::CombatStartOnCast	(	Unit *	target,
		bool	initialAggro = `true`,
		uint32	duration = `0`
	)

Definition at line 13600 of file Unit.cpp.

{
    // Xinef: Dont allow to start combat with triggers
    if (target->GetTypeId() == TYPEID_UNIT && target->ToCreature()->IsTrigger())
        return;
 
    if (initialAggro)
    {
        SetInCombatWith(target, duration);
 
        // Xinef: If pet started combat - put owner in combat
        if (Unit* owner = GetOwner())
            owner->SetInCombatWith(target, duration);
    }
 
    Unit* who = target->GetCharmerOrOwnerOrSelf();
    if (who->GetTypeId() == TYPEID_PLAYER)
        SetContestedPvP(who->ToPlayer());
 
    Player* player = GetCharmerOrOwnerPlayerOrPlayerItself();
    if (player && who->IsPvP() && (who->GetTypeId() != TYPEID_PLAYER || !player->duel || player->duel->Opponent != who))
    {
        player->UpdatePvP(true);
        player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
    }
}

◆ CombatStop()

void Unit::CombatStop ( bool includingCast = false )

Definition at line 10389 of file Unit.cpp.

{
    if (includingCast && IsNonMeleeSpellCast(false))
        InterruptNonMeleeSpells(false);
 
    AttackStop();
    RemoveAllAttackers();
    if (GetTypeId() == TYPEID_PLAYER)
        ToPlayer()->SendAttackSwingCancelAttack();     // melee and ranged forced attack cancel
    ClearInCombat();
 
    // xinef: just in case
    if (IsPetInCombat() && GetTypeId() != TYPEID_PLAYER)
        ClearInPetCombat();
}

◆ CombatStopWithPets()

void Unit::CombatStopWithPets ( bool includingCast = false )

Definition at line 10405 of file Unit.cpp.

{
    CombatStop(includingCast);
 
    for (ControlSet::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
        (*itr)->CombatStop(includingCast);
}

◆ CountPctFromCurHealth()

uint32 Unit::CountPctFromCurHealth ( int32 pct ) const

inline

Definition at line 1448 of file Unit.h.

1448{ return CalculatePct(GetHealth(), pct); }

Unit::GetHealth

uint32 GetHealth() const

Definition: Unit.h:1438

◆ CountPctFromMaxHealth()

uint32 Unit::CountPctFromMaxHealth ( int32 pct ) const

inline

Definition at line 1447 of file Unit.h.

1447{ return CalculatePct(GetMaxHealth(), pct); }

Unit::GetMaxHealth

uint32 GetMaxHealth() const

Definition: Unit.h:1439

◆ CreateTamedPetFrom() [1/2]

Pet * Unit::CreateTamedPetFrom	(	Creature *	creatureTarget,
		uint32	spell_id = `0`
	)

Definition at line 17401 of file Unit.cpp.

{
    if (GetTypeId() != TYPEID_PLAYER)
        return nullptr;
 
    Pet* pet = new Pet(ToPlayer(), HUNTER_PET);
 
    if (!pet->CreateBaseAtCreature(creatureTarget))
    {
        delete pet;
        return nullptr;
    }
 
    uint8 level = creatureTarget->getLevel() + 5 < getLevel() ? (getLevel() - 5) : creatureTarget->getLevel();
 
    if (!InitTamedPet(pet, level, spell_id))
    {
        delete pet;
        return nullptr;
    }
 
    return pet;
}

◆ CreateTamedPetFrom() [2/2]

Pet * Unit::CreateTamedPetFrom	(	uint32	creatureEntry,
		uint32	spell_id = `0`
	)

Definition at line 17425 of file Unit.cpp.

{
    if (GetTypeId() != TYPEID_PLAYER)
        return nullptr;
 
    CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(creatureEntry);
    if (!creatureInfo)
        return nullptr;
 
    Pet* pet = new Pet(ToPlayer(), HUNTER_PET);
 
    if (!pet->CreateBaseAtCreatureInfo(creatureInfo, this) || !InitTamedPet(pet, getLevel(), spell_id))
    {
        delete pet;
        return nullptr;
    }
 
    return pet;
}

◆ CreateVehicleKit()

bool Unit::CreateVehicleKit	(	uint32	id,
		uint32	creatureEntry
	)

Definition at line 18747 of file Unit.cpp.

{
    VehicleEntry const* vehInfo = sVehicleStore.LookupEntry(id);
    if (!vehInfo)
        return false;
 
    m_vehicleKit = new Vehicle(this, vehInfo, creatureEntry);
    m_updateFlag |= UPDATEFLAG_VEHICLE;
    m_unitTypeMask |= UNIT_MASK_VEHICLE;
    return true;
}

◆ DealDamage()

uint32 Unit::DealDamage	(	Unit *	attacker,
		Unit *	victim,
		uint32	damage,
		CleanDamage const *	cleanDamage = `nullptr`,
		DamageEffectType	damagetype = `DIRECT_DAMAGE`,
		SpellSchoolMask	damageSchoolMask = `SPELL_SCHOOL_MASK_NORMAL`,
		SpellInfo const *	spellProto = `nullptr`,
		bool	durabilityLoss = `true`,
		bool	allowGM = `false`,
		Spell const *	spell = `nullptr`
	)

static

Definition at line 814 of file Unit.cpp.

{
    // Xinef: initialize damage done for rage calculations
    // Xinef: its rare to modify damage in hooks, however training dummy's sets damage to 0
    uint32 rage_damage = damage + ((cleanDamage != nullptr) ? cleanDamage->absorbed_damage : 0);
 
    //if (attacker)
    {
        if (victim->IsAIEnabled)
            victim->GetAI()->DamageTaken(attacker, damage, damagetype, damageSchoolMask);
 
        if (attacker && attacker->IsAIEnabled)
            attacker->GetAI()->DamageDealt(victim, damage, damagetype);
    }
 
    // Hook for OnDamage Event
    sScriptMgr->OnDamage(attacker, victim, damage);
 
    if (victim->GetTypeId() == TYPEID_PLAYER && attacker != victim)
    {
        // Signal to pets that their owner was attacked
        Pet* pet = victim->ToPlayer()->GetPet();
 
        if (pet && pet->IsAlive())
            pet->AI()->OwnerAttackedBy(attacker);
    }
 
    //Dont deal damage to unit if .cheat god is enable.
    if (victim->GetTypeId() == TYPEID_PLAYER)
    {
        if (victim->ToPlayer()->GetCommandStatus(CHEAT_GOD))
        {
            return 0;
        }
    }
 
    // Signal the pet it was attacked so the AI can respond if needed
    if (victim->GetTypeId() == TYPEID_UNIT && attacker != victim && victim->IsPet() && victim->IsAlive())
        victim->ToPet()->AI()->AttackedBy(attacker);
 
    if (damagetype != NODAMAGE)
    {
        // interrupting auras with AURA_INTERRUPT_FLAG_DAMAGE before checking !damage (absorbed damage breaks that type of auras)
        if (spellProto)
        {
            if (!spellProto->HasAttribute(SPELL_ATTR4_REACTIVE_DAMAGE_PROC))
                victim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TAKE_DAMAGE, spellProto->Id);
        }
        else
            victim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TAKE_DAMAGE, 0);
 
        // interrupt spells with SPELL_INTERRUPT_FLAG_ABORT_ON_DMG on absorbed damage (no dots)
        if (!damage && damagetype != DOT && cleanDamage && cleanDamage->absorbed_damage)
        {
            if (victim != attacker && victim->GetTypeId() == TYPEID_PLAYER)
            {
                if (Spell* spell = victim->m_currentSpells[CURRENT_GENERIC_SPELL])
                {
                    if (spell->getState() == SPELL_STATE_PREPARING)
                    {
                        uint32 interruptFlags = spell->m_spellInfo->InterruptFlags;
                        if (interruptFlags & SPELL_INTERRUPT_FLAG_ABORT_ON_DMG)
                        {
                            victim->InterruptNonMeleeSpells(false);
                        }
                    }
                }
            }
        }
 
        // We're going to call functions which can modify content of the list during iteration over it's elements
        // Let's copy the list so we can prevent iterator invalidation
        AuraEffectList vCopyDamageCopy(victim->GetAuraEffectsByType(SPELL_AURA_SHARE_DAMAGE_PCT));
        // copy damage to casters of this aura
        for (AuraEffectList::iterator i = vCopyDamageCopy.begin(); i != vCopyDamageCopy.end(); ++i)
        {
            // Check if aura was removed during iteration - we don't need to work on such auras
            if (!((*i)->GetBase()->IsAppliedOnTarget(victim->GetGUID())))
                continue;
            // check damage school mask
            if (((*i)->GetMiscValue() & damageSchoolMask) == 0)
                continue;
 
            Unit* shareDamageTarget = (*i)->GetCaster();
            if (!shareDamageTarget)
                continue;
            SpellInfo const* spell = (*i)->GetSpellInfo();
 
            uint32 shareDamage = CalculatePct(damage, (*i)->GetAmount());
 
            uint32 shareAbsorb = 0;
            uint32 shareResist = 0;
 
            if (shareDamageTarget->IsImmunedToDamageOrSchool(damageSchoolMask))
            {
                shareAbsorb = shareDamage;
                shareDamage = 0;
            }
            else
            {
                DamageInfo sharedDamageInfo(attacker, shareDamageTarget, shareDamage, spellProto, damageSchoolMask, damagetype);
                Unit::CalcAbsorbResist(sharedDamageInfo, true);
                shareAbsorb = sharedDamageInfo.GetAbsorb();
                shareResist = sharedDamageInfo.GetResist();
                shareDamage = sharedDamageInfo.GetDamage();
                Unit::DealDamageMods(shareDamageTarget, shareDamage, &shareAbsorb);
            }
 
            if (attacker && shareDamageTarget->GetTypeId() == TYPEID_PLAYER)
            {
                attacker->SendSpellNonMeleeDamageLog(shareDamageTarget, spell, shareDamage, damageSchoolMask, shareAbsorb, shareResist, damagetype == DIRECT_DAMAGE, 0, false, true);
            }
 
            Unit::DealDamage(attacker, shareDamageTarget, shareDamage, cleanDamage, NODAMAGE, damageSchoolMask, spellProto, false, false, damageSpell);
        }
    }
 
    // Rage from Damage made (only from direct weapon damage)
    if (attacker && cleanDamage && damagetype == DIRECT_DAMAGE && attacker != victim && attacker->getPowerType() == POWER_RAGE)
    {
        uint32 weaponSpeedHitFactor;
 
        switch (cleanDamage->attackType)
        {
            case BASE_ATTACK:
            case OFF_ATTACK:
                {
                    weaponSpeedHitFactor = uint32(attacker->GetAttackTime(cleanDamage->attackType) / 1000.0f * (cleanDamage->attackType == BASE_ATTACK ? 3.5f : 1.75f));
                    if (cleanDamage->hitOutCome == MELEE_HIT_CRIT)
                        weaponSpeedHitFactor *= 2;
 
                    attacker->RewardRage(rage_damage, weaponSpeedHitFactor, true);
                    break;
                }
            case RANGED_ATTACK:
                break;
            default:
                break;
        }
    }
 
    if (!damage)
    {
        // Rage from absorbed damage
        if (cleanDamage && cleanDamage->absorbed_damage)
        {
            if (victim->getPowerType() == POWER_RAGE)
                victim->RewardRage(cleanDamage->absorbed_damage, 0, false);
 
            if (attacker && attacker->getPowerType() == POWER_RAGE )
                attacker->RewardRage(cleanDamage->absorbed_damage, 0, true);
        }
 
        return 0;
    }
 
    LOG_DEBUG("entities.unit", "DealDamageStart");
 
    uint32 health = victim->GetHealth();
    LOG_DEBUG("entities.unit", "deal dmg:{} to health:{} ", damage, health);
 
    // duel ends when player has 1 or less hp
    bool duel_hasEnded = false;
    bool duel_wasMounted = false;
    if (victim->GetTypeId() == TYPEID_PLAYER && victim->ToPlayer()->duel && damage >= (health - 1))
    {
        // xinef: situation not possible earlier, just return silently.
        if (!attacker)
            return 0;
 
        // prevent kill only if killed in duel and killed by opponent or opponent controlled creature
        if (victim->ToPlayer()->duel->Opponent == attacker || victim->ToPlayer()->duel->Opponent->GetGUID() == attacker->GetOwnerGUID())
            damage = health - 1;
 
        duel_hasEnded = true;
    }
    else if (victim->IsVehicle() && damage >= (health - 1) && victim->GetCharmer() && victim->GetCharmer()->GetTypeId() == TYPEID_PLAYER)
    {
        Player* victimRider = victim->GetCharmer()->ToPlayer();
 
        if (victimRider && victimRider->duel && victimRider->duel->IsMounted)
        {
            // xinef: situation not possible earlier, just return silently.
            if (!attacker)
                return 0;
 
            // prevent kill only if killed in duel and killed by opponent or opponent controlled creature
            if (victimRider->duel->Opponent == attacker || victimRider->duel->Opponent->GetGUID() == attacker->GetCharmerGUID())
                damage = health - 1;
 
            duel_wasMounted = true;
            duel_hasEnded = true;
        }
    }
 
    if (attacker && attacker != victim)
        if (Player* killer = attacker->GetCharmerOrOwnerPlayerOrPlayerItself())
        {
            // pussywizard: don't allow GMs to deal damage in normal way (this leaves no evidence in logs!), they have commands to do so
            //if (!allowGM && killer->GetSession()->GetSecurity() && killer->GetSession()->GetSecurity() <= SEC_ADMINISTRATOR)
            //  return 0;
 
            if (Battleground* bg = killer->GetBattleground())
            {
                bg->UpdatePlayerScore(killer, SCORE_DAMAGE_DONE, damage);
                killer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE, damage, 0, victim); // pussywizard: InBattleground() optimization
            }
            //killer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_DEALT, damage); // pussywizard: optimization
        }
 
    if (victim->GetTypeId() == TYPEID_PLAYER)
        ;//victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED, damage); // pussywizard: optimization
    else if (!victim->IsControlledByPlayer() || victim->IsVehicle())
    {
        if (!victim->ToCreature()->hasLootRecipient())
            victim->ToCreature()->SetLootRecipient(attacker);
 
        if (!attacker || attacker->IsControlledByPlayer() || attacker->IsCreatedByPlayer())
        {
            uint32 unDamage = health < damage ? health : damage;
            bool damagedByPlayer = unDamage && attacker && attacker->m_movedByPlayer != nullptr;
            victim->ToCreature()->LowerPlayerDamageReq(unDamage, damagedByPlayer);
        }
    }
 
    if (health <= damage)
    {
        LOG_DEBUG("entities.unit", "DealDamage: victim just died");
 
        //if (attacker && victim->GetTypeId() == TYPEID_PLAYER && victim != attacker)
        //victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, health); // pussywizard: optimization
        Unit::Kill(attacker, victim, durabilityLoss, cleanDamage ? cleanDamage->attackType : BASE_ATTACK, spellProto, damageSpell);
    }
    else
    {
        LOG_DEBUG("entities.unit", "DealDamageAlive");
 
        //if (victim->GetTypeId() == TYPEID_PLAYER)
        //    victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, damage); // pussywizard: optimization
 
        victim->ModifyHealth(- (int32)damage);
 
        if (damagetype == DIRECT_DAMAGE || damagetype == SPELL_DIRECT_DAMAGE)
            victim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_DIRECT_DAMAGE, spellProto ? spellProto->Id : 0);
 
        if (victim->GetTypeId() != TYPEID_PLAYER)
        {
            // Part of Evade mechanics. DoT's and Thorns / Retribution Aura do not contribute to this
            if (damagetype != DOT && damage > 0 && !victim->GetOwnerGUID().IsPlayer() && (!spellProto || !spellProto->HasAura(SPELL_AURA_DAMAGE_SHIELD)))
                victim->ToCreature()->SetLastDamagedTime(GameTime::GetGameTime().count() + MAX_AGGRO_RESET_TIME);
 
            if (attacker)
            {
                if (spellProto && !victim->IsInCombatWith(attacker))
                {
                    victim->CombatStart(attacker, !(spellProto->AttributesEx3 & SPELL_ATTR3_SUPRESS_TARGET_PROCS));
                }
 
                victim->AddThreat(attacker, float(damage), damageSchoolMask, spellProto);
            }
        }
        else                                                // victim is a player
        {
            // random durability for items (HIT TAKEN)
            if (roll_chance_f(sWorld->getRate(RATE_DURABILITY_LOSS_DAMAGE)))
            {
                EquipmentSlots slot = EquipmentSlots(urand(0, EQUIPMENT_SLOT_END - 1));
                victim->ToPlayer()->DurabilityPointLossForEquipSlot(slot);
            }
        }
 
        // Rage from damage received
        if (attacker != victim && victim->getPowerType() == POWER_RAGE)
        {
            uint32 rageDamage = damage + (cleanDamage ? cleanDamage->absorbed_damage : 0);
            victim->RewardRage(rageDamage, 0, false);
        }
 
        if (attacker && attacker->GetTypeId() == TYPEID_PLAYER)
        {
            // random durability for items (HIT DONE)
            if (roll_chance_f(sWorld->getRate(RATE_DURABILITY_LOSS_DAMAGE)))
            {
                EquipmentSlots slot = EquipmentSlots(urand(0, EQUIPMENT_SLOT_END - 1));
                attacker->ToPlayer()->DurabilityPointLossForEquipSlot(slot);
            }
        }
 
        if (damagetype != NODAMAGE && damage && (!spellProto || !(spellProto->HasAttribute(SPELL_ATTR3_TREAT_AS_PERIODIC) || spellProto->HasAttribute(SPELL_ATTR7_DONT_CAUSE_SPELL_PUSHBACK))))
        {
            if (victim != attacker && victim->GetTypeId() == TYPEID_PLAYER) // does not support creature push_back
            {
                if (damagetype != DOT && !(damageSpell && damageSpell->m_targets.HasDstChannel()))
                {
                    if (Spell* spell = victim->m_currentSpells[CURRENT_GENERIC_SPELL])
                    {
                        if (spell->getState() == SPELL_STATE_PREPARING)
                        {
                            uint32 interruptFlags = spell->m_spellInfo->InterruptFlags;
                            if (interruptFlags & SPELL_INTERRUPT_FLAG_ABORT_ON_DMG)
                            {
                                victim->InterruptNonMeleeSpells(false);
                            }
                            else if (interruptFlags & SPELL_INTERRUPT_FLAG_PUSH_BACK)
                            {
                                spell->Delayed();
                            }
                        }
                    }
 
                    if (Spell* spell = victim->m_currentSpells[CURRENT_CHANNELED_SPELL])
                        if (spell->getState() == SPELL_STATE_CASTING)
                        {
                            if ((spell->m_spellInfo->ChannelInterruptFlags & CHANNEL_FLAG_DELAY) != 0)
                            {
                                spell->DelayedChannel();
                            }
                        }
                }
            }
        }
 
        // last damage from duel opponent
        if (duel_hasEnded)
        {
            Player* he = duel_wasMounted ? victim->GetCharmer()->ToPlayer() : victim->ToPlayer();
 
            ASSERT_NODEBUGINFO(he && he->duel);
 
            if (duel_wasMounted) // In this case victim==mount
                victim->SetHealth(1);
            else
                he->SetHealth(1);
 
            he->duel->Opponent->CombatStopWithPets(true);
            he->CombatStopWithPets(true);
 
            he->CastSpell(he, 7267, true);                  // beg
            he->DuelComplete(DUEL_WON);
        }
    }
 
    LOG_DEBUG("entities.unit", "DealDamageEnd returned {} damage", damage);
 
    return damage;
}

◆ DealDamageMods()

void Unit::DealDamageMods	(	Unit const *	victim,
		uint32 &	damage,
		uint32 *	absorb
	)

static

Definition at line 804 of file Unit.cpp.

{
    if (!victim || !victim->IsAlive() || victim->IsInFlight() || (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsEvadingAttacks()))
    {
        if (absorb)
            *absorb += damage;
        damage = 0;
    }
}

◆ DealHeal()

int32 Unit::DealHeal	(	Unit *	healer,
		Unit *	victim,
		uint32	addhealth
	)

static

Definition at line 10899 of file Unit.cpp.

{
    int32 gain = 0;
 
    if (healer)
    {
        if (victim->IsAIEnabled)
            victim->GetAI()->HealReceived(healer, addhealth);
 
        if (healer->IsAIEnabled)
            healer->GetAI()->HealDone(victim, addhealth);
    }
 
    if (addhealth)
        gain = victim->ModifyHealth(int32(addhealth));
 
    // Hook for OnHeal Event
    sScriptMgr->OnHeal(healer, victim, (uint32&)gain);
 
    Unit* unit = healer;
 
    if (healer && healer->GetTypeId() == TYPEID_UNIT && healer->ToCreature()->IsTotem())
        unit = healer->GetOwner();
 
    if (!unit)
        return gain;
 
    if (Player* player = unit->ToPlayer())
    {
        if (Battleground* bg = player->GetBattleground())
            bg->UpdatePlayerScore(player, SCORE_HEALING_DONE, gain);
 
        // use the actual gain, as the overheal shall not be counted, skip gain 0 (it ignored anyway in to criteria)
        if (gain && player->InBattleground()) // pussywizard: InBattleground() optimization
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE, gain, 0, victim);
 
        //player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CASTED, addhealth); // pussywizard: optimization
    }
 
    /*if (Player* player = victim->ToPlayer())
    {
        //player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED, gain); // pussywizard: optimization
        //player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED, addhealth); // pussywizard: optimization
    }*/
 
    return gain;
}

◆ DealMeleeDamage()

void Unit::DealMeleeDamage	(	CalcDamageInfo *	damageInfo,
		bool	durabilityLoss
	)

Definition at line 1809 of file Unit.cpp.

{
    Unit* victim = damageInfo->target;
 
    auto canTakeMeleeDamage = [&]()
    {
        return victim->IsAlive() && !victim->HasUnitState(UNIT_STATE_IN_FLIGHT) && (victim->GetTypeId() != TYPEID_UNIT || !victim->ToCreature()->IsEvadingAttacks());
    };
 
    if (!canTakeMeleeDamage())
    {
        return;
    }
 
    // Hmmmm dont like this emotes client must by self do all animations
    if (damageInfo->HitInfo & HITINFO_CRITICALHIT)
        victim->HandleEmoteCommand(EMOTE_ONESHOT_WOUND_CRITICAL);
    if (damageInfo->blocked_amount && damageInfo->TargetState != VICTIMSTATE_BLOCKS)
        victim->HandleEmoteCommand(EMOTE_ONESHOT_PARRY_SHIELD);
 
    if (damageInfo->TargetState == VICTIMSTATE_PARRY)
    {
        // Get attack timers
        float offtime  = float(victim->getAttackTimer(OFF_ATTACK));
        float basetime = float(victim->getAttackTimer(BASE_ATTACK));
        // Reduce attack time
        if (victim->haveOffhandWeapon() && offtime < basetime)
        {
            float percent20 = victim->GetAttackTime(OFF_ATTACK) * 0.20f;
            float percent60 = 3.0f * percent20;
            if (offtime > percent20 && offtime <= percent60)
                victim->setAttackTimer(OFF_ATTACK, uint32(percent20));
            else if (offtime > percent60)
            {
                offtime -= 2.0f * percent20;
                victim->setAttackTimer(OFF_ATTACK, uint32(offtime));
            }
        }
        else
        {
            float percent20 = victim->GetAttackTime(BASE_ATTACK) * 0.20f;
            float percent60 = 3.0f * percent20;
            if (basetime > percent20 && basetime <= percent60)
                victim->setAttackTimer(BASE_ATTACK, uint32(percent20));
            else if (basetime > percent60)
            {
                basetime -= 2.0f * percent20;
                victim->setAttackTimer(BASE_ATTACK, uint32(basetime));
            }
        }
    }
 
    for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
    {
        if (!canTakeMeleeDamage() || (!damageInfo->damages[i].damage && !damageInfo->damages[i].absorb && !damageInfo->damages[i].resist))
        {
            continue;
        }
 
        // Call default DealDamage
        CleanDamage cleanDamage(damageInfo->cleanDamage, damageInfo->damages[i].absorb, damageInfo->attackType, damageInfo->hitOutCome);
        Unit::DealDamage(this, victim, damageInfo->damages[i].damage, &cleanDamage, DIRECT_DAMAGE, SpellSchoolMask(damageInfo->damages[i].damageSchoolMask), nullptr, durabilityLoss);
    }
 
    // If this is a creature and it attacks from behind it has a probability to daze it's victim
    if ((damageInfo->damages[0].damage + damageInfo->damages[1].damage) && ((damageInfo->hitOutCome == MELEE_HIT_CRIT || damageInfo->hitOutCome == MELEE_HIT_CRUSHING || damageInfo->hitOutCome == MELEE_HIT_NORMAL || damageInfo->hitOutCome == MELEE_HIT_GLANCING) &&
                               GetTypeId() != TYPEID_PLAYER && !ToCreature()->IsControlledByPlayer() && !victim->HasInArc(M_PI, this)
                               && (victim->GetTypeId() == TYPEID_PLAYER || !victim->ToCreature()->isWorldBoss()) && !victim->IsVehicle()))
    {
        // -probability is between 0% and 40%
        // 20% base chance
        float Probability = 20.0f;
 
        // there is a newbie protection, at level 10 just 7% base chance; assuming linear function
        if (victim->getLevel() < 30)
            Probability = 0.65f * victim->getLevel() + 0.5f;
 
        uint32 VictimDefense = victim->GetDefenseSkillValue();
        uint32 AttackerMeleeSkill = GetUnitMeleeSkill();
 
        // xinef: fix daze mechanics
        Probability -= ((float)VictimDefense - AttackerMeleeSkill) * 0.1428f;
 
        if (Probability > 40.0f)
            Probability = 40.0f;
 
        if (roll_chance_f(std::max(0.0f, Probability)))
            CastSpell(victim, 1604, true);
    }
 
    if (GetTypeId() == TYPEID_PLAYER)
        ToPlayer()->CastItemCombatSpell(victim, damageInfo->attackType, damageInfo->procVictim, damageInfo->procEx);
 
    // Do effect if any damage done to target
    if (damageInfo->damages[0].damage + damageInfo->damages[1].damage)
    {
        // We're going to call functions which can modify content of the list during iteration over it's elements
        // Let's copy the list so we can prevent iterator invalidation
        AuraEffectList vDamageShieldsCopy(victim->GetAuraEffectsByType(SPELL_AURA_DAMAGE_SHIELD));
        for (AuraEffectList::const_iterator dmgShieldItr = vDamageShieldsCopy.begin(); dmgShieldItr != vDamageShieldsCopy.end(); ++dmgShieldItr)
        {
            SpellInfo const* i_spellProto = (*dmgShieldItr)->GetSpellInfo();
            // Damage shield can be resisted...
            if (SpellMissInfo missInfo = victim->SpellHitResult(this, i_spellProto, false))
            {
                victim->SendSpellMiss(this, i_spellProto->Id, missInfo);
                continue;
            }
 
            // ...or immuned
            if (IsImmunedToDamageOrSchool(i_spellProto))
            {
                victim->SendSpellDamageImmune(this, i_spellProto->Id);
                continue;
            }
 
            uint32 damage = uint32(std::max(0, (*dmgShieldItr)->GetAmount())); // xinef: done calculated at amount calculation
 
            if (Unit* caster = (*dmgShieldItr)->GetCaster())
            {
                damage = caster->SpellDamageBonusDone(this, i_spellProto, damage, SPELL_DIRECT_DAMAGE, (*dmgShieldItr)->GetEffIndex());
                damage = this->SpellDamageBonusTaken(caster, i_spellProto, damage, SPELL_DIRECT_DAMAGE);
            }
 
            uint32 absorb = 0;
 
            DamageInfo dmgInfo(victim, this, damage, i_spellProto, i_spellProto->GetSchoolMask(), SPELL_DIRECT_DAMAGE);
            Unit::CalcAbsorbResist(dmgInfo);
            absorb = dmgInfo.GetAbsorb();
            damage = dmgInfo.GetDamage();
 
            Unit::DealDamageMods(this, damage, &absorb);
 
            // TODO: Move this to a packet handler
            WorldPacket data(SMSG_SPELLDAMAGESHIELD, (8 + 8 + 4 + 4 + 4 + 4));
            data << victim->GetGUID();
            data << GetGUID();
            data << uint32(i_spellProto->Id);
            data << uint32(damage);                  // Damage
            int32 overkill = int32(damage) - int32(GetHealth());
            data << uint32(overkill > 0 ? overkill : 0); // Overkill
            data << uint32(i_spellProto->GetSchoolMask());
            victim->SendMessageToSet(&data, true);
 
            Unit::DealDamage(victim, this, damage, 0, SPELL_DIRECT_DAMAGE, i_spellProto->GetSchoolMask(), i_spellProto, true);
        }
    }
}

◆ DealSpellDamage()

void Unit::DealSpellDamage	(	SpellNonMeleeDamage *	damageInfo,
		bool	durabilityLoss,
		Spell const *	spell = `nullptr`
	)

Definition at line 1434 of file Unit.cpp.

{
    if (damageInfo == 0)
        return;
 
    Unit* victim = damageInfo->target;
 
    if (!victim)
        return;
 
    if (!victim->IsAlive() || victim->IsInFlight() || (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsEvadingAttacks()))
        return;
 
    SpellInfo const* spellProto = damageInfo->spellInfo;
    if (!spellProto)
    {
        LOG_DEBUG("entities.unit", "Unit::DealSpellDamage has wrong damageInfo");
        return;
    }
 
    // Call default DealDamage
    CleanDamage cleanDamage(damageInfo->cleanDamage, damageInfo->absorb, BASE_ATTACK, MELEE_HIT_NORMAL);
    Unit::DealDamage(this, victim, damageInfo->damage, &cleanDamage, SPELL_DIRECT_DAMAGE, SpellSchoolMask(damageInfo->schoolMask), spellProto, durabilityLoss, false, spell);
}

◆ DelayOwnedAuras()

void Unit::DelayOwnedAuras	(	uint32	spellId,
		ObjectGuid	caster,
		int32	delaytime
	)

Definition at line 5368 of file Unit.cpp.

{
    AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
    for (; range.first != range.second; ++range.first)
    {
        Aura* aura = range.first->second;
        if (!caster || aura->GetCasterGUID() == caster)
        {
            if (aura->GetDuration() < delaytime)
                aura->SetDuration(0);
            else
                aura->SetDuration(aura->GetDuration() - delaytime);
 
            // update for out of range group members (on 1 slot use)
            aura->SetNeedClientUpdateForTargets();
            LOG_DEBUG("spells.aura", "Aura {} partially interrupted on unit {}, new duration: {} ms", aura->GetId(), GetGUID().ToString(), aura->GetDuration());
        }
    }
}

◆ DeleteCharmInfo()

void Unit::DeleteCharmInfo ( )

Definition at line 15657 of file Unit.cpp.

{
    if (!m_charmInfo)
        return;
 
    m_charmInfo->RestoreState();
    delete m_charmInfo;
    m_charmInfo = nullptr;
}

◆ DeMorph()

void Unit::DeMorph ( )

Definition at line 4277 of file Unit.cpp.

{
    SetDisplayId(GetNativeDisplayId());
}

◆ DisableRotate()

void Unit::DisableRotate ( bool apply )

Definition at line 18293 of file Unit.cpp.

{
    if (GetTypeId() != TYPEID_UNIT)
        return;
 
    if (apply)
        SetUnitFlag(UNIT_FLAG_POSSESSED);
    else if (!HasUnitState(UNIT_STATE_POSSESSED))
        RemoveUnitFlag(UNIT_FLAG_POSSESSED);
}

◆ DisableSpline()

void Unit::DisableSpline ( )

Definition at line 654 of file Unit.cpp.

{
    m_movementInfo.RemoveMovementFlag(MovementFlags(MOVEMENTFLAG_SPLINE_ENABLED | MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_BACKWARD));
    movespline->_Interrupt();
}

◆ Dismount()

void Unit::Dismount ( )

Definition at line 13428 of file Unit.cpp.

{
    if (!IsMounted())
        return;
 
    SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, 0);
    RemoveUnitFlag(UNIT_FLAG_MOUNT);
 
    if (Player* thisPlayer = ToPlayer())
    {
        WorldPacket data(SMSG_MOVE_SET_COLLISION_HGT, GetPackGUID().size() + 4 + 4);
        data << GetPackGUID();
        data << uint32(GameTime::GetGameTime().count());   // Packet counter
        data << thisPlayer->GetCollisionHeight();
        thisPlayer->GetSession()->SendPacket(&data);
    }
 
    WorldPacket data(SMSG_DISMOUNT, 8);
    data << GetPackGUID();
    SendMessageToSet(&data, true);
 
    // dismount as a vehicle
    if (GetTypeId() == TYPEID_PLAYER && GetVehicleKit())
    {
        // Send other players that we are no longer a vehicle
        data.Initialize(SMSG_PLAYER_VEHICLE_DATA, 8 + 4);
        data << GetPackGUID();
        data << uint32(0);
        ToPlayer()->SendMessageToSet(&data, true);
        // Remove vehicle from player
        RemoveVehicleKit();
    }
 
    RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_NOT_MOUNTED);
 
    // only resummon old pet if the player is already added to a map
    // this prevents adding a pet to a not created map which would otherwise cause a crash
    // (it could probably happen when logging in after a previous crash)
    if (Player* player = ToPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(player);
 
        if (Pet* pPet = player->GetPet())
        {
            if (pPet->HasUnitFlag(UNIT_FLAG_STUNNED) && !pPet->HasUnitState(UNIT_STATE_STUNNED))
                pPet->RemoveUnitFlag(UNIT_FLAG_STUNNED);
        }
        else
            player->ResummonPetTemporaryUnSummonedIfAny();
 
        // xinef: if we have charmed npc, remove stun also
        if (Unit* charm = player->GetCharm())
            if (charm->GetTypeId() == TYPEID_UNIT && !charm->HasUnitState(UNIT_STATE_STUNNED))
                charm->RemoveUnitFlag(UNIT_FLAG_STUNNED);
    }
}

◆ EnergizeBySpell()

void Unit::EnergizeBySpell	(	Unit *	victim,
		uint32	SpellID,
		uint32	Damage,
		Powers	powertype
	)

Definition at line 11215 of file Unit.cpp.

{
    victim->ModifyPower(powerType, damage, false);
 
    if (powerType != POWER_HAPPINESS)
    {
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellID);
        victim->getHostileRefMgr().threatAssist(this, float(damage) * 0.5f, spellInfo);
    }
 
    SendEnergizeSpellLog(victim, spellID, damage, powerType);
}

◆ EnterVehicle()

void Unit::EnterVehicle	(	Unit *	base,
		int8	seatId = `-1`
	)

Definition at line 19651 of file Unit.cpp.

{
    CastCustomSpell(VEHICLE_SPELL_RIDE_HARDCODED, SPELLVALUE_BASE_POINT0, seatId + 1, base, TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE);
 
    if (Player* player = ToPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(player);
        sScriptMgr->AnticheatSetSkipOnePacketForASH(player, true);
    }
}

◆ EnterVehicleUnattackable()

void Unit::EnterVehicleUnattackable	(	Unit *	base,
		int8	seatId = `-1`
	)

Definition at line 19662 of file Unit.cpp.

{
    CastCustomSpell(67830, SPELLVALUE_BASE_POINT0, seatId + 1, base, true);
}

◆ ExecuteDelayedUnitAINotifyEvent()

void Unit::ExecuteDelayedUnitAINotifyEvent ( )

Definition at line 20602 of file Unit.cpp.

{
    this->RemoveFromNotify(NOTIFY_AI_RELOCATION);
    if (!this->IsInWorld() || this->IsDuringRemoveFromWorld())
        return;
 
    Acore::AIRelocationNotifier notifier(*this);
    float radius = 60.0f;
    Cell::VisitAllObjects(this, notifier, radius);
}

◆ ExecuteDelayedUnitRelocationEvent()

void Unit::ExecuteDelayedUnitRelocationEvent ( )

Definition at line 20495 of file Unit.cpp.

{
    this->RemoveFromNotify(NOTIFY_VISIBILITY_CHANGED);
    if (!this->IsInWorld() || this->IsDuringRemoveFromWorld())
        return;
 
    if (this->HasSharedVision())
        for (SharedVisionList::const_iterator itr = this->GetSharedVisionList().begin(); itr != this->GetSharedVisionList().end(); ++itr)
            if (Player* player = (*itr))
            {
                if (player->IsOnVehicle(this) || !player->IsInWorld() || player->IsDuringRemoveFromWorld()) // players on vehicles have their own event executed (due to passenger relocation)
                    continue;
                WorldObject* viewPoint = player;
                if (player->m_seer && player->m_seer->IsInWorld())
                    viewPoint = player->m_seer;
                if (!viewPoint->IsPositionValid() || !player->IsPositionValid())
                    continue;
 
                if (Unit* active = viewPoint->ToUnit())
                {
                    //if (active->IsVehicle()) // always check original unit here, last notify position is not relocated
                    //  active = player;
 
                    float dx = active->m_last_notify_position.GetPositionX() - active->GetPositionX();
                    float dy = active->m_last_notify_position.GetPositionY() - active->GetPositionY();
                    float dz = active->m_last_notify_position.GetPositionZ() - active->GetPositionZ();
                    float distsq = dx * dx + dy * dy + dz * dz;
                    float mindistsq = DynamicVisibilityMgr::GetReqMoveDistSq(active->FindMap()->GetEntry()->map_type);
                    if (distsq < mindistsq)
                        continue;
 
                    // this will be relocated below sharedvision!
                    //active->m_last_notify_position.Relocate(active->GetPositionX(), active->GetPositionY(), active->GetPositionZ());
                }
 
                Acore::PlayerRelocationNotifier relocateNoLarge(*player, false); // visit only objects which are not large; default distance
                Cell::VisitAllObjects(viewPoint, relocateNoLarge, player->GetSightRange() + VISIBILITY_INC_FOR_GOBJECTS);
                relocateNoLarge.SendToSelf();
                Acore::PlayerRelocationNotifier relocateLarge(*player, true);    // visit only large objects; maximum distance
                Cell::VisitAllObjects(viewPoint, relocateLarge, MAX_VISIBILITY_DISTANCE);
                relocateLarge.SendToSelf();
            }
 
    if (Player* player = this->ToPlayer())
    {
        WorldObject* viewPoint = player;
        if (player->m_seer && player->m_seer->IsInWorld())
            viewPoint = player->m_seer;
 
        if (viewPoint->GetMapId() != player->GetMapId() || !viewPoint->IsPositionValid() || !player->IsPositionValid())
            return;
 
        if (Unit* active = viewPoint->ToUnit())
        {
            if (active->IsVehicle())
                active = player;
 
            if (!player->GetFarSightDistance())
            {
                float dx     = active->m_last_notify_position.GetPositionX() - active->GetPositionX();
                float dy     = active->m_last_notify_position.GetPositionY() - active->GetPositionY();
                float dz     = active->m_last_notify_position.GetPositionZ() - active->GetPositionZ();
                float distsq = dx * dx + dy * dy + dz * dz;
 
                float mindistsq = DynamicVisibilityMgr::GetReqMoveDistSq(active->FindMap()->GetEntry()->map_type);
                if (distsq < mindistsq)
                    return;
 
                active->m_last_notify_position.Relocate(active->GetPositionX(), active->GetPositionY(), active->GetPositionZ());
            }
        }
 
        Acore::PlayerRelocationNotifier relocateNoLarge(*player, false); // visit only objects which are not large; default distance
        Cell::VisitAllObjects(viewPoint, relocateNoLarge, player->GetSightRange() + VISIBILITY_INC_FOR_GOBJECTS);
        relocateNoLarge.SendToSelf();
 
        if (!player->GetFarSightDistance())
        {
            Acore::PlayerRelocationNotifier relocateLarge(*player, true); // visit only large objects; maximum distance
            Cell::VisitAllObjects(viewPoint, relocateLarge, MAX_VISIBILITY_DISTANCE);
            relocateLarge.SendToSelf();
        }
 
        this->AddToNotify(NOTIFY_AI_RELOCATION);
    }
    else if (Creature* unit = this->ToCreature())
    {
        if (!unit->IsPositionValid())
            return;
 
        float dx = unit->m_last_notify_position.GetPositionX() - unit->GetPositionX();
        float dy = unit->m_last_notify_position.GetPositionY() - unit->GetPositionY();
        float dz = unit->m_last_notify_position.GetPositionZ() - unit->GetPositionZ();
        float distsq = dx * dx + dy * dy + dz * dz;
        float mindistsq = DynamicVisibilityMgr::GetReqMoveDistSq(unit->FindMap()->GetEntry()->map_type);
        if (distsq < mindistsq)
            return;
 
        unit->m_last_notify_position.Relocate(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ());
 
        Acore::CreatureRelocationNotifier relocate(*unit);
        Cell::VisitAllObjects(unit, relocate, unit->GetVisibilityRange() + VISIBILITY_COMPENSATION);
 
        this->AddToNotify(NOTIFY_AI_RELOCATION);
    }
}

◆ ExitVehicle()

void Unit::ExitVehicle ( Position const * exitPosition = nullptr )

This function can be called at upper level code to initialize an exit from the passenger's side.

The following call would not even be executed successfully as the SPELL_AURA_CONTROL_VEHICLE unapply handler already calls _ExitVehicle without specifying an exitposition. The subsequent call below would return on if (!m_vehicle).

To do: We need to allow SPELL_AURA_CONTROL_VEHICLE unapply handlers in spellscripts to specify exit coordinates and either store those per passenger, or we need to init spline movement based on those coordinates in unapply handlers, and relocate exiting passengers based on Unit::moveSpline data. Either way, Coming Soon(TM)

Definition at line 19749 of file Unit.cpp.

{
    if (!m_vehicle)
        return;
 
    GetVehicleBase()->RemoveAurasByType(SPELL_AURA_CONTROL_VEHICLE, GetGUID());
    if (Player* player = ToPlayer())
    {
        player->SetCanTeleport(true);
    }
    /*_ExitVehicle(exitPosition);*/
 
    if (Player* player = ToPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(player);
        sScriptMgr->AnticheatSetSkipOnePacketForASH(player, true);
    }
}

◆ FindCurrentSpellBySpellId()

Spell * Unit::FindCurrentSpellBySpellId ( uint32 spell_id ) const

Definition at line 4072 of file Unit.cpp.

{
    for (uint32 i = 0; i < CURRENT_MAX_SPELL; i++)
        if (m_currentSpells[i] && m_currentSpells[i]->m_spellInfo->Id == spell_id)
            return m_currentSpells[i];
    return nullptr;
}

◆ FinishSpell()

void Unit::FinishSpell	(	CurrentSpellTypes	spellType,
		bool	ok = `true`
	)

Definition at line 4015 of file Unit.cpp.

{
    Spell* spell = m_currentSpells[spellType];
    if (!spell)
        return;
 
    if (spellType == CURRENT_CHANNELED_SPELL)
        spell->SendChannelUpdate(0);
 
    spell->finish(ok);
}

◆ GetAffectingPlayer()

Player * Unit::GetAffectingPlayer ( ) const

Definition at line 10573 of file Unit.cpp.

{
    if (!GetCharmerOrOwnerGUID())
        return const_cast<Unit*>(this)->ToPlayer();
 
    if (Unit* owner = GetCharmerOrOwner())
        return owner->GetCharmerOrOwnerPlayerOrPlayerItself();
 
    return nullptr;
}

◆ GetAI()

UnitAI * Unit::GetAI ( )

inline

Definition at line 1316 of file Unit.h.

1316{ return i_AI; }

◆ GetAllMinionsByEntry()

void Unit::GetAllMinionsByEntry	(	std::list< Creature * > &	Minions,
		uint32	entry
	)

Definition at line 10799 of file Unit.cpp.

{
    for (Unit::ControlSet::iterator itr = m_Controlled.begin(); itr != m_Controlled.end();)
    {
        Unit* unit = *itr;
        ++itr;
        if (unit->GetEntry() == entry && unit->GetTypeId() == TYPEID_UNIT
                && unit->ToCreature()->IsSummon()) // minion, actually
            Minions.push_back(unit->ToCreature());
    }
}

◆ GetAPMultiplier()

float Unit::GetAPMultiplier	(	WeaponAttackType	attType,
		bool	normalized
	)

Definition at line 17279 of file Unit.cpp.

{
    if (!normalized || GetTypeId() != TYPEID_PLAYER)
        return float(GetAttackTime(attType)) / 1000.0f;
 
    Item* Weapon = ToPlayer()->GetWeaponForAttack(attType, true);
    if (!Weapon)
        return 2.4f;                                         // fist attack
 
    switch (Weapon->GetTemplate()->InventoryType)
    {
        case INVTYPE_2HWEAPON:
            return 3.3f;
        case INVTYPE_RANGED:
        case INVTYPE_RANGEDRIGHT:
        case INVTYPE_THROWN:
            return 2.8f;
        case INVTYPE_WEAPON:
        case INVTYPE_WEAPONMAINHAND:
        case INVTYPE_WEAPONOFFHAND:
        default:
            return Weapon->GetTemplate()->SubClass == ITEM_SUBCLASS_WEAPON_DAGGER ? 1.7f : 2.4f;
    }
}

◆ GetAppliedAuras() [1/2]

AuraApplicationMap & Unit::GetAppliedAuras ( )

inline

Definition at line 1921 of file Unit.h.

1921{ return m_appliedAuras; }

◆ GetAppliedAuras() [2/2]

AuraApplicationMap const & Unit::GetAppliedAuras ( ) const

inline

Definition at line 1922 of file Unit.h.

1922{ return m_appliedAuras; }

◆ GetArmor()

uint32 Unit::GetArmor ( ) const

inline

Definition at line 1430 of file Unit.h.

1430{ return GetResistance(SPELL_SCHOOL_NORMAL); }

SPELL_SCHOOL_NORMAL

@ SPELL_SCHOOL_NORMAL

Definition: SharedDefines.h:255

Unit::GetResistance

uint32 GetResistance(SpellSchools school) const

Definition: Unit.h:1433

◆ getAttackerForHelper()

Unit * Unit::getAttackerForHelper ( ) const

inline

Definition at line 1366 of file Unit.h.

    {
        if (GetVictim() != nullptr)
            return GetVictim();
 
        if (!IsEngaged())
            return nullptr;
 
        if (!m_attackers.empty())
            return *(m_attackers.begin());
 
        return nullptr;
    }

◆ getAttackers()

AttackerSet const & Unit::getAttackers ( ) const

inline

Definition at line 1383 of file Unit.h.

1383{ return m_attackers; }

◆ GetAttackTime()

uint32 Unit::GetAttackTime ( WeaponAttackType att ) const

inline

Definition at line 1467 of file Unit.h.

    {
        float f_BaseAttackTime = GetFloatValue(static_cast<uint16>(UNIT_FIELD_BASEATTACKTIME) + att) / m_modAttackSpeedPct[att];
        return (uint32)f_BaseAttackTime;
    }

◆ getAttackTimer()

int32 Unit::getAttackTimer ( WeaponAttackType type ) const

inline

Definition at line 1342 of file Unit.h.

1342{ return m_attackTimer[type]; }

◆ GetAura()

Aura * Unit::GetAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint8	reqEffMask = `0`
	)		const

Definition at line 5487 of file Unit.cpp.

{
    AuraApplication* aurApp = GetAuraApplication(spellId, casterGUID, itemCasterGUID, reqEffMask);
    return aurApp ? aurApp->GetBase() : nullptr;
}

◆ GetAuraApplication()

AuraApplication * Unit::GetAuraApplication	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint8	reqEffMask = `0`,
		AuraApplication *	except = `nullptr`
	)		const

Definition at line 5468 of file Unit.cpp.

{
    AuraApplicationMapBounds range = m_appliedAuras.equal_range(spellId);
    for (; range.first != range.second; ++range.first)
    {
        AuraApplication* app = range.first->second;
        Aura const* aura = app->GetBase();
 
        if (((aura->GetEffectMask() & reqEffMask) == reqEffMask)
                && (!casterGUID || aura->GetCasterGUID() == casterGUID)
                && (!itemCasterGUID || aura->GetCastItemGUID() == itemCasterGUID)
                && (!except || except != app))
        {
            return app;
        }
    }
    return nullptr;
}

◆ GetAuraApplicationOfRankedSpell()

AuraApplication * Unit::GetAuraApplicationOfRankedSpell	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint8	reqEffMask = `0`,
		AuraApplication *	except = `nullptr`
	)		const

Definition at line 5493 of file Unit.cpp.

{
    uint32 rankSpell = sSpellMgr->GetFirstSpellInChain(spellId);
    while (rankSpell)
    {
        if (AuraApplication* aurApp = GetAuraApplication(rankSpell, casterGUID, itemCasterGUID, reqEffMask, except))
            return aurApp;
        rankSpell = sSpellMgr->GetNextSpellInChain(rankSpell);
    }
    return nullptr;
}

◆ GetAuraCount()

uint32 Unit::GetAuraCount ( uint32 spellId ) const

Definition at line 5582 of file Unit.cpp.

{
    uint32 count = 0;
    AuraApplicationMapBounds range = m_appliedAuras.equal_range(spellId);
 
    for (AuraApplicationMap::const_iterator itr = range.first; itr != range.second; ++itr)
    {
        if (itr->second->GetBase()->GetStackAmount() == 0)
            ++count;
        else
            count += (uint32)itr->second->GetBase()->GetStackAmount();
    }
 
    return count;
}

◆ GetAuraEffect() [1/3]

AuraEffect * Unit::GetAuraEffect	(	AuraType	type,
		SpellFamilyNames	family,
		uint32	familyFlag1,
		uint32	familyFlag2,
		uint32	familyFlag3,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`
	)		const

Definition at line 5440 of file Unit.cpp.

{
    AuraEffectList const& auras = GetAuraEffectsByType(type);
    for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
    {
        SpellInfo const* spell = (*i)->GetSpellInfo();
        if (spell->SpellFamilyName == uint32(family) && spell->SpellFamilyFlags.HasFlag(familyFlag1, familyFlag2, familyFlag3))
        {
            if (casterGUID && (*i)->GetCasterGUID() != casterGUID)
                continue;
            return (*i);
        }
    }
    return nullptr;
}

◆ GetAuraEffect() [2/3]

AuraEffect * Unit::GetAuraEffect	(	AuraType	type,
		SpellFamilyNames	name,
		uint32	iconId,
		uint8	effIndex
	)		const

Definition at line 5426 of file Unit.cpp.

{
    AuraEffectList const& auras = GetAuraEffectsByType(type);
    for (Unit::AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
    {
        if (effIndex != (*itr)->GetEffIndex())
            continue;
        SpellInfo const* spell = (*itr)->GetSpellInfo();
        if (spell->SpellIconID == iconId && spell->SpellFamilyName == name)
            return *itr;
    }
    return nullptr;
}

◆ GetAuraEffect() [3/3]

AuraEffect * Unit::GetAuraEffect	(	uint32	spellId,
		uint8	effIndex,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`
	)		const

Definition at line 5400 of file Unit.cpp.

{
    AuraApplicationMapBounds range = m_appliedAuras.equal_range(spellId);
    for (AuraApplicationMap::const_iterator itr = range.first; itr != range.second; ++itr)
    {
        if (itr->second->HasEffect(effIndex)
                && (!caster || itr->second->GetBase()->GetCasterGUID() == caster))
        {
            return itr->second->GetBase()->GetEffect(effIndex);
        }
    }
    return nullptr;
}

◆ GetAuraEffectDummy()

AuraEffect * Unit::GetAuraEffectDummy ( uint32 spellid ) const

Definition at line 5456 of file Unit.cpp.

{
    AuraEffectList const& auras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
    for (Unit::AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
    {
        if ((*itr)->GetId() == spellid)
            return *itr;
    }
 
    return nullptr;
}

◆ GetAuraEffectOfRankedSpell()

AuraEffect * Unit::GetAuraEffectOfRankedSpell	(	uint32	spellId,
		uint8	effIndex,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`
	)		const

Definition at line 5414 of file Unit.cpp.

{
    uint32 rankSpell = sSpellMgr->GetFirstSpellInChain(spellId);
    while (rankSpell)
    {
        if (AuraEffect* aurEff = GetAuraEffect(rankSpell, effIndex, caster))
            return aurEff;
        rankSpell = sSpellMgr->GetNextSpellInChain(rankSpell);
    }
    return nullptr;
}

◆ GetAuraEffectsByType()

AuraEffectList const & Unit::GetAuraEffectsByType ( AuraType type ) const

inline

Definition at line 1964 of file Unit.h.

1964{ return m_modAuras[type]; }

◆ GetAuraOfRankedSpell()

Aura * Unit::GetAuraOfRankedSpell	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint8	reqEffMask = `0`
	)		const

Definition at line 5505 of file Unit.cpp.

{
    AuraApplication* aurApp = GetAuraApplicationOfRankedSpell(spellId, casterGUID, itemCasterGUID, reqEffMask);
    return aurApp ? aurApp->GetBase() : nullptr;
}

◆ GetCastingTimeForBonus()

uint32 Unit::GetCastingTimeForBonus	(	SpellInfo const *	spellProto,
		DamageEffectType	damagetype,
		uint32	CastingTime
	)		const

Definition at line 17139 of file Unit.cpp.

{
    // Not apply this to creature casted spells with casttime == 0
    if (CastingTime == 0 && GetTypeId() == TYPEID_UNIT && !IsPet())
        return 3500;
 
    if (CastingTime > 7000) CastingTime = 7000;
    if (CastingTime < 1500) CastingTime = 1500;
 
    if (damagetype == DOT && !spellProto->IsChanneled())
        CastingTime = 3500;
 
    int32 overTime    = 0;
    uint8 effects     = 0;
    bool DirectDamage = false;
    bool AreaEffect   = false;
 
    for (uint32 i = 0; i < MAX_SPELL_EFFECTS; i++)
    {
        switch (spellProto->Effects[i].Effect)
        {
            case SPELL_EFFECT_SCHOOL_DAMAGE:
            case SPELL_EFFECT_POWER_DRAIN:
            case SPELL_EFFECT_HEALTH_LEECH:
            case SPELL_EFFECT_ENVIRONMENTAL_DAMAGE:
            case SPELL_EFFECT_POWER_BURN:
            case SPELL_EFFECT_HEAL:
                DirectDamage = true;
                break;
            case SPELL_EFFECT_APPLY_AURA:
                switch (spellProto->Effects[i].ApplyAuraName)
                {
                    case SPELL_AURA_PERIODIC_DAMAGE:
                    case SPELL_AURA_PERIODIC_HEAL:
                    case SPELL_AURA_PERIODIC_LEECH:
                        if (spellProto->GetDuration())
                            overTime = spellProto->GetDuration();
                        break;
                    default:
                        // -5% per additional effect
                        ++effects;
                        break;
                }
            default:
                break;
        }
 
        if (spellProto->Effects[i].IsTargetingArea())
            AreaEffect = true;
    }
 
    // Combined Spells with Both Over Time and Direct Damage
    if (overTime > 0 && DirectDamage)
    {
        // mainly for DoTs which are 3500 here otherwise
        uint32 OriginalCastTime = spellProto->CalcCastTime();
        if (OriginalCastTime > 7000) OriginalCastTime = 7000;
        if (OriginalCastTime < 1500) OriginalCastTime = 1500;
        // Portion to Over Time
        float PtOT = (overTime / 15000.0f) / ((overTime / 15000.0f) + (OriginalCastTime / 3500.0f));
 
        if (damagetype == DOT)
            CastingTime = uint32(CastingTime * PtOT);
        else if (PtOT < 1.0f)
            CastingTime  = uint32(CastingTime * (1 - PtOT));
        else
            CastingTime = 0;
    }
 
    // Area Effect Spells receive only half of bonus
    if (AreaEffect)
        CastingTime /= 2;
 
    // 50% for damage and healing spells for leech spells from damage bonus and 0% from healing
    for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
    {
        if (spellProto->Effects[j].Effect == SPELL_EFFECT_HEALTH_LEECH ||
                (spellProto->Effects[j].Effect == SPELL_EFFECT_APPLY_AURA && spellProto->Effects[j].ApplyAuraName == SPELL_AURA_PERIODIC_LEECH))
        {
            CastingTime /= 2;
            break;
        }
    }
 
    // -5% of total per any additional effect
    for (uint8 i = 0; i < effects; ++i)
        CastingTime *= 0.95f;
 
    return CastingTime;
}

◆ GetCharm()

Unit * Unit::GetCharm ( ) const

Definition at line 10614 of file Unit.cpp.

{
    if (ObjectGuid charm_guid = GetCharmGUID())
    {
        if (Unit* pet = ObjectAccessor::GetUnit(*this, charm_guid))
            return pet;
 
        LOG_ERROR("entities.unit", "Unit::GetCharm: Charmed creature {} not exist.", charm_guid.ToString());
        const_cast<Unit*>(this)->SetGuidValue(UNIT_FIELD_CHARM, ObjectGuid::Empty);
    }
 
    return nullptr;
}

◆ GetCharmer()

Unit * Unit::GetCharmer ( ) const

Definition at line 10556 of file Unit.cpp.

{
    if (ObjectGuid charmerGUID = GetCharmerGUID())
        return ObjectAccessor::GetUnit(*this, charmerGUID);
 
    return nullptr;
}

◆ GetCharmerGUID()

ObjectGuid Unit::GetCharmerGUID ( ) const

inline

Definition at line 1817 of file Unit.h.

1817{ return GetGuidValue(UNIT_FIELD_CHARMEDBY); }

UNIT_FIELD_CHARMEDBY

@ UNIT_FIELD_CHARMEDBY

Definition: UpdateFields.h:89

Object::GetGuidValue

ObjectGuid GetGuidValue(uint16 index) const

Definition: Object.cpp:337

◆ GetCharmerOrOwner()

Unit * Unit::GetCharmerOrOwner ( ) const

inline

Definition at line 1844 of file Unit.h.

1844{ return GetCharmerGUID() ? GetCharmer() : GetOwner(); }

◆ GetCharmerOrOwnerGUID()

ObjectGuid Unit::GetCharmerOrOwnerGUID ( ) const

inline

Definition at line 1827 of file Unit.h.

1827{ return GetCharmerGUID() ? GetCharmerGUID() : GetOwnerGUID(); }

◆ GetCharmerOrOwnerOrOwnGUID()

ObjectGuid Unit::GetCharmerOrOwnerOrOwnGUID ( ) const

inline

Definition at line 1828 of file Unit.h.

    {
        if (ObjectGuid guid = GetCharmerOrOwnerGUID())
            return guid;
 
        return GetGUID();
    }

◆ GetCharmerOrOwnerOrSelf()

Unit * Unit::GetCharmerOrOwnerOrSelf ( ) const

inline

Definition at line 1845 of file Unit.h.

    {
        if (Unit* u = GetCharmerOrOwner())
            return u;
 
        return (Unit*)this;
    }

◆ GetCharmerOrOwnerPlayerOrPlayerItself()

Player * Unit::GetCharmerOrOwnerPlayerOrPlayerItself ( ) const

Definition at line 10564 of file Unit.cpp.

{
    ObjectGuid guid = GetCharmerOrOwnerGUID();
    if (guid.IsPlayer())
        return ObjectAccessor::GetPlayer(*this, guid);
 
    return const_cast<Unit*>(this)->ToPlayer();
}

◆ GetCharmGUID()

ObjectGuid Unit::GetCharmGUID ( ) const

inline

Definition at line 1819 of file Unit.h.

1819{ return GetGuidValue(UNIT_FIELD_CHARM); }

◆ GetCharmInfo()

CharmInfo * Unit::GetCharmInfo ( )

inline

Definition at line 1880 of file Unit.h.

1880{ return m_charmInfo; }

◆ getClass()

uint8 Unit::getClass ( ) const

inline

Definition at line 1424 of file Unit.h.

1424{ return GetByteValue(UNIT_FIELD_BYTES_0, 1); }

UNIT_FIELD_BYTES_0

@ UNIT_FIELD_BYTES_0

Definition: UpdateFields.h:95

Object::GetByteValue

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:323

◆ getClassMask()

uint32 Unit::getClassMask ( ) const

inline

Definition at line 1425 of file Unit.h.

1425{ return 1 << (getClass() - 1); }

◆ GetCollisionHeight()

float Unit::GetCollisionHeight ( ) const

overridevirtual

Return collision height sent to client.

Reimplemented from WorldObject.

Definition at line 21110 of file Unit.cpp.

{
    float scaleMod = GetObjectScale(); // 99% sure about this
    float defaultHeight = DEFAULT_COLLISION_HEIGHT * scaleMod;
 
    CreatureDisplayInfoEntry const* displayInfo = sCreatureDisplayInfoStore.AssertEntry(GetNativeDisplayId());
    CreatureModelDataEntry const* modelData = sCreatureModelDataStore.AssertEntry(displayInfo->ModelId);
    float collisionHeight = 0.0f;
 
    if (IsMounted())
    {
        if (CreatureDisplayInfoEntry const* mountDisplayInfo = sCreatureDisplayInfoStore.LookupEntry(GetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID)))
        {
            if (CreatureModelDataEntry const* mountModelData = sCreatureModelDataStore.LookupEntry(mountDisplayInfo->ModelId))
            {
                collisionHeight = scaleMod * (mountModelData->MountHeight + modelData->CollisionHeight * modelData->Scale * displayInfo->scale * 0.5f);
            }
        }
    }
    else
        collisionHeight = scaleMod * modelData->CollisionHeight * modelData->Scale * displayInfo->scale;
 
    return collisionHeight == 0.0f ? defaultHeight : collisionHeight;
}

◆ GetCollisionRadius()

float Unit::GetCollisionRadius ( ) const

overridevirtual

this method gets the radius of a Unit by DB if any value is defined, otherwise it gets the value by the DBC

If the player is mounted the radius also takes in consideration the mount size

Returns: float The radius of a unit

Reimplemented from WorldObject.

Definition at line 21104 of file Unit.cpp.

{
    return GetCollisionWidth() / 2;
}

◆ GetCollisionWidth()

float Unit::GetCollisionWidth ( ) const

overridevirtual

this method gets the diameter of a Unit by DB if any value is defined, otherwise it gets the value by the DBC

If the player is mounted the diameter also takes in consideration the mount size

Returns: float The diameter of a unit

Dismounting case - use basic default model data

Reimplemented from WorldObject.

Definition at line 21067 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_PLAYER)
        return GetObjectSize();
 
    float scaleMod = GetObjectScale(); // 99% sure about this
    float objectSize = GetObjectSize();
    float defaultSize = DEFAULT_WORLD_OBJECT_SIZE * scaleMod;
 
    CreatureDisplayInfoEntry const* displayInfo = sCreatureDisplayInfoStore.AssertEntry(GetNativeDisplayId());
    CreatureModelDataEntry const* modelData = sCreatureModelDataStore.AssertEntry(displayInfo->ModelId);
 
    if (IsMounted())
    {
        if (CreatureDisplayInfoEntry const* mountDisplayInfo = sCreatureDisplayInfoStore.LookupEntry(GetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID)))
        {
            if (CreatureModelDataEntry const* mountModelData = sCreatureModelDataStore.LookupEntry(mountDisplayInfo->ModelId))
            {
                if (G3D::fuzzyGt(mountModelData->CollisionWidth, modelData->CollisionWidth))
                    modelData = mountModelData;
            }
        }
    }
 
    float collisionWidth = scaleMod * modelData->CollisionWidth * modelData->Scale * displayInfo->scale * 2;
    // if the objectSize is the default value or the creature is mounted and we have a DBC value, then we can retrieve DBC value instead
    return G3D::fuzzyGt(collisionWidth, 0.0f) && (G3D::fuzzyEq(objectSize,defaultSize) || IsMounted())  ? collisionWidth : objectSize;
}

◆ GetCombatRatingDamageReduction()

uint32 Unit::GetCombatRatingDamageReduction	(	CombatRating	cr,
		float	rate,
		float	cap,
		uint32	damage
	)		const

private

Definition at line 19227 of file Unit.cpp.

{
    float percent = std::min(GetCombatRatingReduction(cr) * rate, cap);
    return CalculatePct(damage, percent);
}

◆ GetCombatRatingReduction()

float Unit::GetCombatRatingReduction ( CombatRating cr ) const

private

Definition at line 19215 of file Unit.cpp.

{
    if (Player const* player = ToPlayer())
        return player->GetRatingBonusValue(cr);
    // Player's pet get resilience from owner
    else if (IsPet() && GetOwner())
        if (Player* owner = GetOwner()->ToPlayer())
            return owner->GetRatingBonusValue(cr);
 
    return 0.0f;
}

◆ GetCombatReach()

float Unit::GetCombatReach ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

Definition at line 1347 of file Unit.h.

1347{ return m_floatValues[UNIT_FIELD_COMBATREACH]; }

UNIT_FIELD_COMBATREACH

@ UNIT_FIELD_COMBATREACH

Definition: UpdateFields.h:123

◆ GetCombatTimer()

uint32 Unit::GetCombatTimer ( ) const

inline

Definition at line 1695 of file Unit.h.

1695{ return m_CombatTimer; }

◆ GetComboPoints() [1/2]

uint8 Unit::GetComboPoints ( ObjectGuid const & guid ) const

inline

Definition at line 2286 of file Unit.h.

2286{ return (m_comboTarget && m_comboTarget->GetGUID() == guid) ? m_comboPoints : 0; }

◆ GetComboPoints() [2/2]

uint8 Unit::GetComboPoints ( Unit const * who = nullptr ) const

inline

--------—Combo point system----------------—

Definition at line 2285 of file Unit.h.

2285{ return (who && m_comboTarget != who) ? 0 : m_comboPoints; }

◆ GetComboTarget()

Unit * Unit::GetComboTarget ( ) const

inline

Definition at line 2287 of file Unit.h.

2287{ return m_comboTarget; }

◆ GetComboTargetGUID()

ObjectGuid const Unit::GetComboTargetGUID ( ) const

inline

Definition at line 2288 of file Unit.h.

2288{ return m_comboTarget ? m_comboTarget->GetGUID() : ObjectGuid::Empty; }

◆ GetCreateHealth()

uint32 Unit::GetCreateHealth ( ) const

inline

Definition at line 2036 of file Unit.h.

2036{ return GetUInt32Value(UNIT_FIELD_BASE_HEALTH); }

UNIT_FIELD_BASE_HEALTH

@ UNIT_FIELD_BASE_HEALTH

Definition: UpdateFields.h:160

◆ GetCreateMana()

uint32 Unit::GetCreateMana ( ) const

inline

Definition at line 2038 of file Unit.h.

2038{ return GetUInt32Value(UNIT_FIELD_BASE_MANA); }

UNIT_FIELD_BASE_MANA

@ UNIT_FIELD_BASE_MANA

Definition: UpdateFields.h:159

◆ GetCreatePowers()

uint32 Unit::GetCreatePowers ( Powers power ) const

Definition at line 15497 of file Unit.cpp.

{
    // Only hunter pets have POWER_FOCUS and POWER_HAPPINESS
    switch (power)
    {
        case POWER_MANA:
            return GetCreateMana();
        case POWER_RAGE:
            return 1000;
        case POWER_FOCUS:
            return (GetTypeId() == TYPEID_PLAYER || !((Creature const*)this)->IsPet() || ((Pet const*)this)->getPetType() != HUNTER_PET ? 0 : 100);
        case POWER_ENERGY:
            return 100;
        case POWER_HAPPINESS:
            return (GetTypeId() == TYPEID_PLAYER || !((Creature const*)this)->IsPet() || ((Pet const*)this)->getPetType() != HUNTER_PET ? 0 : 1050000);
        case POWER_RUNIC_POWER:
            return 1000;
        case POWER_RUNE:
            return 0;
        case POWER_HEALTH:
            return 0;
        default:
            break;
    }
 
    return 0;
}

◆ GetCreateStat()

float Unit::GetCreateStat ( Stats stat ) const

inline

Definition at line 2042 of file Unit.h.

2042{ return m_createStats[stat]; }

◆ GetCreatorGUID()

ObjectGuid Unit::GetCreatorGUID ( ) const

inline

Definition at line 1813 of file Unit.h.

1813{ return GetGuidValue(UNIT_FIELD_CREATEDBY); }

UNIT_FIELD_CREATEDBY

@ UNIT_FIELD_CREATEDBY

Definition: UpdateFields.h:91

◆ GetCreatureType()

uint32 Unit::GetCreatureType ( ) const

Definition at line 15039 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_PLAYER)
    {
        ShapeshiftForm form = GetShapeshiftForm();
        SpellShapeshiftEntry const* ssEntry = sSpellShapeshiftStore.LookupEntry(form);
        if (ssEntry && ssEntry->creatureType > 0)
            return ssEntry->creatureType;
        else
            return CREATURE_TYPE_HUMANOID;
    }
    else
        return ToCreature()->GetCreatureTemplate()->type;
}

◆ GetCreatureTypeMask()

uint32 Unit::GetCreatureTypeMask ( ) const

inline

Definition at line 1526 of file Unit.h.

    {
        uint32 creatureType = GetCreatureType();
        return (creatureType >= 1) ? (1 << (creatureType - 1)) : 0;
    }

◆ GetCritterGUID()

ObjectGuid Unit::GetCritterGUID ( ) const

inline

Definition at line 1823 of file Unit.h.

1823{ return GetGuidValue(UNIT_FIELD_CRITTER); }

UNIT_FIELD_CRITTER

@ UNIT_FIELD_CRITTER

Definition: UpdateFields.h:88

◆ GetCurrentSpell() [1/2]

Spell * Unit::GetCurrentSpell ( CurrentSpellTypes spellType ) const

inline

Definition at line 2058 of file Unit.h.

2058{ return m_currentSpells[spellType]; }

◆ GetCurrentSpell() [2/2]

Spell * Unit::GetCurrentSpell ( uint32 spellType ) const

inline

Definition at line 2059 of file Unit.h.

2059{ return m_currentSpells[spellType]; }

◆ GetCurrentSpellCastTime()

int32 Unit::GetCurrentSpellCastTime ( uint32 spell_id ) const

Definition at line 4080 of file Unit.cpp.

{
    if (Spell const* spell = FindCurrentSpellBySpellId(spell_id))
        return spell->GetCastTime();
    return 0;
}

◆ getDeathState()

DeathState Unit::getDeathState ( )

inline

Definition at line 1808 of file Unit.h.

1808{ return m_deathState; };

◆ GetDebugInfo()

std::string Unit::GetDebugInfo ( ) const

overridevirtual

Reimplemented from WorldObject.

Definition at line 21299 of file Unit.cpp.

{
    std::stringstream sstr;
    sstr << WorldObject::GetDebugInfo() << "\n"
        << std::boolalpha
        << "AliveState: " << IsAlive()
        << " UnitMovementFlags: " << GetUnitMovementFlags() << " ExtraUnitMovementFlags: " << GetExtraUnitMovementFlags()
        << " Class: " << std::to_string(getClass());
    return sstr.str();
}

◆ GetDefaultMovementType()

MovementGeneratorType Unit::GetDefaultMovementType ( ) const

virtual

-------—End of Pet responses methods-------—

Reimplemented in Creature.

Definition at line 16731 of file Unit.cpp.

{
    return IDLE_MOTION_TYPE;
}

◆ GetDefenseSkillValue()

uint32 Unit::GetDefenseSkillValue ( Unit const * target = nullptr ) const

Definition at line 3566 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_PLAYER)
    {
        // in PvP use full skill instead current skill value
        uint32 value = (target && target->GetTypeId() == TYPEID_PLAYER)
                       ? ToPlayer()->GetMaxSkillValue(SKILL_DEFENSE)
                       : ToPlayer()->GetSkillValue(SKILL_DEFENSE);
        value += uint32(ToPlayer()->GetRatingBonusValue(CR_DEFENSE_SKILL));
        return value;
    }
    else
        return GetUnitMeleeSkill(target);
}

◆ GetDiminishing()

DiminishingLevels Unit::GetDiminishing ( DiminishingGroup group )

Definition at line 14864 of file Unit.cpp.

{
    for (Diminishing::iterator i = m_Diminishing.begin(); i != m_Diminishing.end(); ++i)
    {
        if (i->DRGroup != group)
            continue;
 
        if (!i->hitCount)
            return DIMINISHING_LEVEL_1;
 
        if (!i->hitTime)
            return DIMINISHING_LEVEL_1;
 
        // If last spell was casted more than 15 seconds ago - reset the count.
        if (i->stack == 0 && getMSTimeDiff(i->hitTime, GameTime::GetGameTimeMS().count()) > 15000)
        {
            i->hitCount = DIMINISHING_LEVEL_1;
            return DIMINISHING_LEVEL_1;
        }
        // or else increase the count.
        else
            return DiminishingLevels(i->hitCount);
    }
    return DIMINISHING_LEVEL_1;
}

◆ GetDirectTransport()

TransportBase * Unit::GetDirectTransport ( ) const

Returns the transport this unit is on directly (if on vehicle and transport, return vehicle)

Definition at line 18799 of file Unit.cpp.

{
    if (Vehicle* veh = GetVehicle())
        return veh;
    return GetTransport();
}

◆ GetDiseasesByCaster()

uint32 Unit::GetDiseasesByCaster	(	ObjectGuid	casterGUID,
		uint8	mode = `0`
	)

Definition at line 5721 of file Unit.cpp.

{
    static const AuraType diseaseAuraTypes[] =
    {
        SPELL_AURA_PERIODIC_DAMAGE, // Frost Fever and Blood Plague
        SPELL_AURA_LINKED,          // Crypt Fever and Ebon Plague
        SPELL_AURA_NONE
    };
 
    ObjectGuid drwGUID;
 
    if (Player* playerCaster = ObjectAccessor::GetPlayer(*this, casterGUID))
        drwGUID = playerCaster->getRuneWeaponGUID();
 
    uint32 diseases = 0;
    for (uint8 index = 0; diseaseAuraTypes[index] != SPELL_AURA_NONE; ++index)
    {
        for (AuraEffectList::iterator i = m_modAuras[diseaseAuraTypes[index]].begin(); i != m_modAuras[diseaseAuraTypes[index]].end();)
        {
            // Get auras with disease dispel type by caster
            if ((*i)->GetSpellInfo()->Dispel == DISPEL_DISEASE
                    && ((*i)->GetCasterGUID() == casterGUID || (*i)->GetCasterGUID() == drwGUID)) // if its caster or his dancing rune weapon
            {
                ++diseases;
 
                if (mode == 1)
                {
                    RemoveAura((*i)->GetId(), (*i)->GetCasterGUID());
                    i = m_modAuras[diseaseAuraTypes[index]].begin();
                    continue;
                }
                // used for glyph of scourge strike
                else if (mode == 2)
                {
                    Aura* aura = (*i)->GetBase();
                    if (aura && !aura->IsRemoved() && aura->GetDuration() > 0)
                        if ((aura->GetApplyTime() + aura->GetMaxDuration() / 1000 + 8) > (GameTime::GetGameTime().count() + aura->GetDuration() / 1000))
                            aura->SetDuration(aura->GetDuration() + 3000);
                }
            }
            ++i;
        }
    }
    return diseases;
}

◆ GetDispellableAuraList()

void Unit::GetDispellableAuraList	(	Unit *	caster,
		uint32	dispelMask,
		DispelChargesList &	dispelList
	)

Definition at line 5511 of file Unit.cpp.

{
    // we should not be able to dispel diseases if the target is affected by unholy blight
    if (dispelMask & (1 << DISPEL_DISEASE) && HasAura(50536))
        dispelMask &= ~(1 << DISPEL_DISEASE);
 
    ReputationRank rank = GetReactionTo(caster, IsCharmed());
    bool positive = rank >= REP_FRIENDLY;
 
    // Neutral unit not at war with caster should be treated as a friendly unit
    if (rank == REP_NEUTRAL)
    {
        if (Player* casterPlayer = caster->GetAffectingPlayer())
        {
            if (FactionTemplateEntry const* factionTemplateEntry = GetFactionTemplateEntry())
            {
                if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionTemplateEntry->faction))
                {
                    if (factionEntry->CanBeSetAtWar())
                    {
                        positive = !casterPlayer->GetReputationMgr().IsAtWar(factionEntry);
                    }
                }
            }
        }
    }
 
    Unit::VisibleAuraMap const* visibleAuras = GetVisibleAuras();
    for (Unit::VisibleAuraMap::const_iterator itr = visibleAuras->begin(); itr != visibleAuras->end(); ++itr)
    {
        Aura* aura = itr->second->GetBase();
 
        // don't try to remove passive auras
        if (aura->IsPassive())
            continue;
 
        if (aura->GetSpellInfo()->GetDispelMask() & dispelMask)
        {
            if (aura->GetSpellInfo()->Dispel == DISPEL_MAGIC)
            {
                // do not remove positive auras if friendly target
                //               negative auras if non-friendly target
                if (itr->second->IsPositive() == positive)
                    continue;
            }
 
            // The charges / stack amounts don't count towards the total number of auras that can be dispelled.
            // Ie: A dispel on a target with 5 stacks of Winters Chill and a Polymorph has 1 / (1 + 1) -> 50% chance to dispell
            // Polymorph instead of 1 / (5 + 1) -> 16%.
            bool dispel_charges = aura->GetSpellInfo()->HasAttribute(SPELL_ATTR7_DISPEL_REMOVES_CHARGES);
            uint8 charges = dispel_charges ? aura->GetCharges() : aura->GetStackAmount();
            if (charges > 0)
                dispelList.push_back(std::make_pair(aura, charges));
        }
    }
}

◆ GetDisplayId()

uint32 Unit::GetDisplayId ( ) const

inline

Definition at line 2163 of file Unit.h.

2163{ return GetUInt32Value(UNIT_FIELD_DISPLAYID); }

◆ GetDoTsByCaster()

uint32 Unit::GetDoTsByCaster ( ObjectGuid casterGUID ) const

Definition at line 5767 of file Unit.cpp.

{
    static const AuraType diseaseAuraTypes[] =
    {
        SPELL_AURA_PERIODIC_DAMAGE,
        SPELL_AURA_PERIODIC_DAMAGE_PERCENT,
        SPELL_AURA_NONE
    };
 
    uint32 dots = 0;
    for (AuraType const* itr = &diseaseAuraTypes[0]; itr && itr[0] != SPELL_AURA_NONE; ++itr)
    {
        Unit::AuraEffectList const& auras = GetAuraEffectsByType(*itr);
        for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
        {
            // Get auras by caster
            if ((*i)->GetCasterGUID() == casterGUID)
                ++dots;
        }
    }
    return dots;
}

◆ GetDummyAuraEffect()

AuraEffect * Unit::GetDummyAuraEffect	(	SpellFamilyNames	name,
		uint32	iconId,
		uint8	effIndex
	)		const

inline

Definition at line 1973 of file Unit.h.

1973{ return GetAuraEffect(SPELL_AURA_DUMMY, name, iconId, effIndex);}

◆ GetDynamicFlags()

uint32 Unit::GetDynamicFlags ( ) const

inlineoverridevirtual

Reimplemented from Object.

Definition at line 1325 of file Unit.h.

1325{ return GetUInt32Value(UNIT_DYNAMIC_FLAGS); }

◆ GetDynObject()

DynamicObject * Unit::GetDynObject ( uint32 spellId )

Definition at line 6028 of file Unit.cpp.

{
    if (m_dynObj.empty())
        return nullptr;
    for (DynObjectList::const_iterator i = m_dynObj.begin(); i != m_dynObj.end(); ++i)
    {
        DynamicObject* dynObj = *i;
        if (dynObj->GetSpellId() == spellId)
            return dynObj;
    }
    return nullptr;
}

◆ GetEffectiveResistChance()

float Unit::GetEffectiveResistChance	(	Unit const *	owner,
		SpellSchoolMask	schoolMask,
		Unit const *	victim
	)

static

Definition at line 2071 of file Unit.cpp.

{
    float victimResistance = float(victim->GetResistance(schoolMask));
    if (owner)
    {
        // Xinef: pets inherit 100% of masters penetration
        // Xinef: excluding traps
        Player const* player = owner->GetSpellModOwner();
        if (player && owner->GetEntry() != WORLD_TRIGGER)
        {
            victimResistance += float(player->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask));
            victimResistance -= float(player->GetSpellPenetrationItemMod());
        }
        else
            victimResistance += float(owner->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask));
    }
 
    victimResistance = std::max(victimResistance, 0.0f);
    if (owner)
        victimResistance += std::max((float(victim->getLevel()) - float(owner->getLevel())) * 5.0f, 0.0f);
 
    static uint32 const BOSS_LEVEL = 83;
    static float const BOSS_RESISTANCE_CONSTANT = 510.0f;
    uint32 level = victim->getLevel();
    float resistanceConstant = 0.0f;
 
    if (level == BOSS_LEVEL)
        resistanceConstant = BOSS_RESISTANCE_CONSTANT;
    else
        resistanceConstant = level * 5.0f;
 
    return victimResistance / (victimResistance + resistanceConstant);
}

◆ GetExtraUnitMovementFlags()

uint16 Unit::GetExtraUnitMovementFlags ( ) const

inline

Definition at line 2276 of file Unit.h.

2276{ return m_movementInfo.flags2; }

◆ GetFaction()

uint32 Unit::GetFaction ( ) const

inline

Definition at line 1493 of file Unit.h.

1493{ return GetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE); }

◆ GetFactionReactionTo()

ReputationRank Unit::GetFactionReactionTo	(	FactionTemplateEntry const *	factionTemplateEntry,
		Unit const *	target
	)		const

Definition at line 10145 of file Unit.cpp.

{
    // always neutral when no template entry found
    if (!factionTemplateEntry)
        return REP_NEUTRAL;
 
    FactionTemplateEntry const* targetFactionTemplateEntry = target->GetFactionTemplateEntry();
    if (!targetFactionTemplateEntry)
        return REP_NEUTRAL;
 
    // xinef: check forced reputation for self also
    if (Player const* selfPlayerOwner = GetAffectingPlayer())
        if (ReputationRank const* repRank = selfPlayerOwner->GetReputationMgr().GetForcedRankIfAny(target->GetFactionTemplateEntry()))
            return *repRank;
 
    if (Player const* targetPlayerOwner = target->GetAffectingPlayer())
    {
        // check contested flags
        if (factionTemplateEntry->factionFlags & FACTION_TEMPLATE_FLAG_ATTACK_PVP_ACTIVE_PLAYERS
                && targetPlayerOwner->HasPlayerFlag(PLAYER_FLAGS_CONTESTED_PVP))
            return REP_HOSTILE;
        if (ReputationRank const* repRank = targetPlayerOwner->GetReputationMgr().GetForcedRankIfAny(factionTemplateEntry))
            return *repRank;
        if (!target->HasUnitFlag2(UNIT_FLAG2_IGNORE_REPUTATION))
        {
            if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionTemplateEntry->faction))
            {
                if (factionEntry->CanHaveReputation())
                {
                    // CvP case - check reputation, don't allow state higher than neutral when at war
                    ReputationRank repRank = targetPlayerOwner->GetReputationMgr().GetRank(factionEntry);
                    if (targetPlayerOwner->GetReputationMgr().IsAtWar(factionEntry))
                        repRank = std::min(REP_NEUTRAL, repRank);
                    return repRank;
                }
            }
        }
    }
 
    // common faction based check
    if (factionTemplateEntry->IsHostileTo(*targetFactionTemplateEntry))
        return REP_HOSTILE;
    if (factionTemplateEntry->IsFriendlyTo(*targetFactionTemplateEntry))
        return REP_FRIENDLY;
    if (targetFactionTemplateEntry->IsFriendlyTo(*factionTemplateEntry))
        return REP_FRIENDLY;
    if (factionTemplateEntry->factionFlags & FACTION_TEMPLATE_FLAG_HATES_ALL_EXCEPT_FRIENDS)
        return REP_HOSTILE;
    // neutral by default
    return REP_NEUTRAL;
}

◆ GetFactionTemplateEntry()

FactionTemplateEntry const * Unit::GetFactionTemplateEntry ( ) const

Definition at line 9995 of file Unit.cpp.

{
    FactionTemplateEntry const* entry = sFactionTemplateStore.LookupEntry(GetFaction());
    if (!entry)
    {
        static ObjectGuid guid;                             // prevent repeating spam same faction problem
 
        if (GetGUID() != guid)
        {
            if (Player const* player = ToPlayer())
                LOG_ERROR("entities.unit", "Player {} has invalid faction (faction template id) #{}", player->GetName(), GetFaction());
            else if (Creature const* creature = ToCreature())
                LOG_ERROR("entities.unit", "Creature (template id: {}) has invalid faction (faction template id) #{}", creature->GetCreatureTemplate()->Entry, GetFaction());
            else
                LOG_ERROR("entities.unit", "Unit (name={}, type={}) has invalid faction (faction template id) #{}", GetName(), uint32(GetTypeId()), GetFaction());
 
            guid = GetGUID();
        }
    }
    return entry;
}

◆ GetFirstControlled()

Unit * Unit::GetFirstControlled ( ) const

Definition at line 11023 of file Unit.cpp.

{
    // Sequence: charmed, pet, other guardians
    Unit* unit = GetCharm();
    if (!unit)
        if (ObjectGuid guid = GetMinionGUID())
            unit = ObjectAccessor::GetUnit(*this, guid);
 
    return unit;
}

◆ GetFirstMinion()

Minion * Unit::GetFirstMinion ( ) const

Definition at line 10584 of file Unit.cpp.

{
    if (ObjectGuid pet_guid = GetMinionGUID())
    {
        if (Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*this, pet_guid))
            if (pet->HasUnitTypeMask(UNIT_MASK_MINION))
                return (Minion*)pet;
 
        LOG_ERROR("entities.unit", "Unit::GetFirstMinion: Minion {} not exist.", pet_guid.ToString());
        const_cast<Unit*>(this)->SetMinionGUID(ObjectGuid::Empty);
    }
 
    return nullptr;
}

◆ GetFollowAngle()

virtual float Unit::GetFollowAngle ( ) const

inlinevirtual

Reimplemented in Minion.

Definition at line 2387 of file Unit.h.

2387{ return static_cast<float>(M_PI / 2); }

◆ GetGameObject()

GameObject * Unit::GetGameObject ( uint32 spellId ) const

Definition at line 6069 of file Unit.cpp.

{
    for (GameObjectList::const_iterator itr = m_gameObj.begin(); itr != m_gameObj.end(); ++itr)
        if (GameObject* go = ObjectAccessor::GetGameObject(*this, *itr))
            if (go->GetSpellId() == spellId)
                return go;
 
    return nullptr;
}

◆ getGender()

uint8 Unit::getGender ( ) const

inline

Definition at line 1426 of file Unit.h.

1426{ return GetByteValue(UNIT_FIELD_BYTES_0, 2); }

◆ GetGuardianPet()

Guardian * Unit::GetGuardianPet ( ) const

Definition at line 10599 of file Unit.cpp.

{
    if (ObjectGuid pet_guid = GetPetGUID())
    {
        if (Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*this, pet_guid))
            if (pet->HasUnitTypeMask(UNIT_MASK_GUARDIAN))
                return (Guardian*)pet;
 
        LOG_FATAL("entities.unit", "Unit::GetGuardianPet: Guardian {} not exist.", pet_guid.ToString());
        const_cast<Unit*>(this)->SetPetGUID(ObjectGuid::Empty);
    }
 
    return nullptr;
}

◆ GetHealth()

uint32 Unit::GetHealth ( ) const

inline

Definition at line 1438 of file Unit.h.

1438{ return GetUInt32Value(UNIT_FIELD_HEALTH); }

UNIT_FIELD_HEALTH

@ UNIT_FIELD_HEALTH

Definition: UpdateFields.h:96

◆ GetHealthGain()

int32 Unit::GetHealthGain ( int32 dVal )

Definition at line 14013 of file Unit.cpp.

{
    int32 gain = 0;
 
    if (dVal == 0)
        return 0;
 
    int32 curHealth = (int32)GetHealth();
 
    int32 val = dVal + curHealth;
    if (val <= 0)
    {
        return -curHealth;
    }
 
    int32 maxHealth = (int32)GetMaxHealth();
 
    if (val < maxHealth)
        gain = dVal;
    else if (curHealth != maxHealth)
        gain = maxHealth - curHealth;
 
    return gain;
}

◆ GetHealthPct()

float Unit::GetHealthPct ( ) const

inline

Definition at line 1446 of file Unit.h.

1446{ return GetMaxHealth() ? 100.f * GetHealth() / GetMaxHealth() : 0.0f; }

◆ getHostileRefMgr()

HostileRefMgr & Unit::getHostileRefMgr ( )

inline

Definition at line 2146 of file Unit.h.

2146{ return m_HostileRefMgr; }

◆ GetHoverHeight()

float Unit::GetHoverHeight ( ) const

inline

Definition at line 2382 of file Unit.h.

2382{ return IsHovering() ? GetFloatValue(UNIT_FIELD_HOVERHEIGHT) : 0.0f; }

UNIT_FIELD_HOVERHEIGHT

@ UNIT_FIELD_HOVERHEIGHT

Definition: UpdateFields.h:173

Unit::IsHovering

bool IsHovering() const

Definition: Unit.h:2377

◆ GetInterruptMask()

uint32 Unit::GetInterruptMask ( ) const

inline

Definition at line 2159 of file Unit.h.

2159{ return m_interruptMask; }

◆ GetLastDamagedTargetGuid()

ObjectGuid const & Unit::GetLastDamagedTargetGuid ( ) const

inline

Definition at line 1570 of file Unit.h.

1570{ return _lastDamagedTargetGuid; }

◆ GetLastExtraAttackSpell()

uint32 Unit::GetLastExtraAttackSpell ( ) const

inline

Definition at line 1567 of file Unit.h.

1567{ return _lastExtraAttackSpell; }

◆ getLevel()

uint8 Unit::getLevel ( ) const

inline

Definition at line 1418 of file Unit.h.

1418{ return uint8(GetUInt32Value(UNIT_FIELD_LEVEL)); }

UNIT_FIELD_LEVEL

@ UNIT_FIELD_LEVEL

Definition: UpdateFields.h:114

◆ getLevelForTarget()

uint8 Unit::getLevelForTarget ( WorldObject const * ) const

inlineoverridevirtual

Reimplemented from WorldObject.

Definition at line 1419 of file Unit.h.

1419{ return getLevel(); }

◆ GetMagicHitRedirectTarget()

Unit * Unit::GetMagicHitRedirectTarget	(	Unit *	victim,
		SpellInfo const *	spellInfo
	)

Definition at line 10967 of file Unit.cpp.

{
    // Patch 1.2 notes: Spell Reflection no longer reflects abilities
    if (spellInfo->HasAttribute(SPELL_ATTR0_IS_ABILITY) || spellInfo->HasAttribute(SPELL_ATTR1_NO_REDIRECTION) || spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES))
        return victim;
 
    Unit::AuraEffectList const& magnetAuras = victim->GetAuraEffectsByType(SPELL_AURA_SPELL_MAGNET);
    for (Unit::AuraEffectList::const_iterator itr = magnetAuras.begin(); itr != magnetAuras.end(); ++itr)
    {
        if (Unit* magnet = (*itr)->GetBase()->GetUnitOwner())
            if (spellInfo->CheckExplicitTarget(this, magnet) == SPELL_CAST_OK
                    //&& spellInfo->CheckTarget(this, magnet, false) == SPELL_CAST_OK
                    && _IsValidAttackTarget(magnet, spellInfo)
                    /*&& IsWithinLOSInMap(magnet)*/)
            {
                // Xinef: We should choose minimum between flight time and queue time as in reflect, however we dont know flight time at this point, use arbitrary small number
                magnet->m_Events.AddEvent(new RedirectSpellEvent(*magnet, victim->GetGUID(), *itr), magnet->m_Events.CalculateQueueTime(100));
 
                if (magnet->IsTotem())
                {
                    uint64 queueTime = magnet->m_Events.CalculateQueueTime(100);
                    if (spellInfo->Speed > 0.0f)
                    {
                        float dist = GetDistance(magnet->GetPositionX(), magnet->GetPositionY(), magnet->GetPositionZ());
                        if (dist < 5.0f)
                            dist = 5.0f;
                        queueTime = magnet->m_Events.CalculateTime((uint64)floor(dist / spellInfo->Speed * 1000.0f));
                    }
 
                    magnet->m_Events.AddEvent(new KillMagnetEvent(*magnet), queueTime);
                }
 
                return magnet;
            }
    }
    return victim;
}

◆ GetMaxHealth()

uint32 Unit::GetMaxHealth ( ) const

inline

Definition at line 1439 of file Unit.h.

1439{ return GetUInt32Value(UNIT_FIELD_MAXHEALTH); }

UNIT_FIELD_MAXHEALTH

@ UNIT_FIELD_MAXHEALTH

Definition: UpdateFields.h:104

◆ GetMaxNegativeAuraModifier()

int32 Unit::GetMaxNegativeAuraModifier ( AuraType auratype ) const

Definition at line 5849 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if ((*i)->GetAmount() < modifier)
            modifier = (*i)->GetAmount();
 
    return modifier;
}

◆ GetMaxNegativeAuraModifierByAffectMask()

int32 Unit::GetMaxNegativeAuraModifierByAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

Definition at line 6004 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if ((*i)->IsAffectedOnSpell(affectedSpell) && (*i)->GetAmount() < modifier)
            modifier = (*i)->GetAmount();
    }
 
    return modifier;
}

◆ GetMaxNegativeAuraModifierByMiscMask()

int32 Unit::GetMaxNegativeAuraModifierByMiscMask	(	AuraType	auratype,
		uint32	misc_mask
	)		const

Definition at line 5900 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if ((*i)->GetMiscValue()& misc_mask && (*i)->GetAmount() < modifier)
            modifier = (*i)->GetAmount();
    }
 
    return modifier;
}

◆ GetMaxNegativeAuraModifierByMiscValue()

int32 Unit::GetMaxNegativeAuraModifierByMiscValue	(	AuraType	auratype,
		int32	misc_value
	)		const

Definition at line 5952 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if ((*i)->GetMiscValue() == misc_value && (*i)->GetAmount() < modifier)
            modifier = (*i)->GetAmount();
    }
 
    return modifier;
}

◆ GetMaxPositiveAuraModifier()

int32 Unit::GetMaxPositiveAuraModifier ( AuraType auratype )

Definition at line 5835 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if ((*i)->GetAmount() > modifier)
            modifier = (*i)->GetAmount();
    }
 
    return modifier;
}

◆ GetMaxPositiveAuraModifierByAffectMask()

int32 Unit::GetMaxPositiveAuraModifierByAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

Definition at line 5990 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if ((*i)->IsAffectedOnSpell(affectedSpell) && (*i)->GetAmount() > modifier)
            modifier = (*i)->GetAmount();
    }
 
    return modifier;
}

◆ GetMaxPositiveAuraModifierByMiscMask()

int32 Unit::GetMaxPositiveAuraModifierByMiscMask	(	AuraType	auratype,
		uint32	misc_mask,
		const AuraEffect *	except = `nullptr`
	)		const

Definition at line 5886 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if (except != (*i) && (*i)->GetMiscValue()& misc_mask && (*i)->GetAmount() > modifier)
            modifier = (*i)->GetAmount();
    }
 
    return modifier;
}

◆ GetMaxPositiveAuraModifierByMiscValue()

int32 Unit::GetMaxPositiveAuraModifierByMiscValue	(	AuraType	auratype,
		int32	misc_value
	)		const

Definition at line 5938 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if ((*i)->GetMiscValue() == misc_value && (*i)->GetAmount() > modifier)
            modifier = (*i)->GetAmount();
    }
 
    return modifier;
}

◆ GetMaxPower()

uint32 Unit::GetMaxPower ( Powers power ) const

inline

Definition at line 1460 of file Unit.h.

1460{ return GetUInt32Value(static_cast<uint16>(UNIT_FIELD_MAXPOWER1) + power); }

UNIT_FIELD_MAXPOWER1

@ UNIT_FIELD_MAXPOWER1

Definition: UpdateFields.h:105

◆ GetMaxSkillValueForLevel()

uint16 Unit::GetMaxSkillValueForLevel ( Unit const * target = nullptr ) const

inline

Definition at line 1545 of file Unit.h.

1545{ return (target ? getLevelForTarget(target) : getLevel()) * 5; }

Unit::getLevelForTarget

uint8 getLevelForTarget(WorldObject const *) const override

Definition: Unit.h:1419

◆ GetMechanicResistChance()

int32 Unit::GetMechanicResistChance ( SpellInfo const * spell )

Definition at line 3075 of file Unit.cpp.

{
    if (!spell)
        return 0;
    int32 resist_mech = 0;
    for (uint8 eff = 0; eff < MAX_SPELL_EFFECTS; ++eff)
    {
        if (!spell->Effects[eff].IsEffect())
            break;
        int32 effect_mech = spell->GetEffectMechanic(eff);
        if (effect_mech)
        {
            int32 temp = GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_MECHANIC_RESISTANCE, effect_mech);
            if (resist_mech < temp)
                resist_mech = temp;
        }
    }
    return resist_mech;
}

◆ GetMeleeAttackPoint()

bool Unit::GetMeleeAttackPoint	(	Unit *	attacker,
		Position &	pos
	)

Definition at line 2617 of file Unit.cpp.

{
    if (!attacker)
    {
        return false;
    }
 
    AttackerSet attackers = getAttackers();
 
    if (attackers.size() <= 1) // if the attackers are not more than one
    {
        return false;
    }
 
    float meleeReach = GetExactDist2d(attacker);
    if (meleeReach <= 0)
    {
        return false;
    }
 
    float minAngle = 0;
    Unit *refUnit = nullptr;
    uint32 validAttackers = 0;
 
    double attackerSize = attacker->GetCollisionRadius();
 
    for (const auto& otherAttacker: attackers)
    {
        // if the otherAttacker is not valid, skip
        if (!otherAttacker || otherAttacker->GetGUID() == attacker->GetGUID() ||
            !otherAttacker->IsWithinMeleeRange(this) || otherAttacker->isMoving())
        {
            continue;
        }
 
        float curretAngle = atan(attacker->GetExactDist2d(otherAttacker) / meleeReach);
        if (minAngle == 0 || curretAngle < minAngle)
        {
            minAngle = curretAngle;
            refUnit = otherAttacker;
        }
 
        validAttackers++;
    }
 
    if (!validAttackers || !refUnit)
    {
        return false;
    }
 
    float contactDist = attackerSize + refUnit->GetCollisionRadius();
    float requiredAngle = atan(contactDist / meleeReach);
    float attackersAngle = atan(attacker->GetExactDist2d(refUnit) / meleeReach);
 
    // in instance: the more attacker there are, the higher will be the tollerance
    // outside: creatures should not intersecate
    float angleTollerance = attacker->GetMap()->IsDungeon() ? requiredAngle - requiredAngle * tanh(validAttackers / 5.0f) : requiredAngle;
 
    if (attackersAngle > angleTollerance)
    {
        return false;
    }
 
    double angle = atan(contactDist / meleeReach);
 
    float angularRadius = frand(0.1f, 0.3f) + angle;
    int8 direction = (urand(0, 1) ? -1 : 1);
    float currentAngle = GetAngle(refUnit);
    float absAngle = currentAngle + angularRadius * direction;
 
    float x, y, z;
    float distance = meleeReach - GetObjectSize();
    GetNearPoint(attacker, x, y, z, distance, 0.0f, absAngle);
 
    if (!GetMap()->CanReachPositionAndGetValidCoords(this, x, y, z, true, true))
    {
        GetNearPoint(attacker, x, y, z, distance, 0.0f, absAngle * -1); // try the other side
 
        if (!GetMap()->CanReachPositionAndGetValidCoords(this, x, y, z, true, true))
        {
            return false;
        }
    }
 
    pos.Relocate(x, y, z);
 
    return true;
}

◆ GetMeleeCritChanceReduction()

float Unit::GetMeleeCritChanceReduction ( ) const

inline

Definition at line 1576 of file Unit.h.

1576{ return GetCombatRatingReduction(CR_CRIT_TAKEN_MELEE); }

◆ GetMeleeCritDamageReduction()

uint32 Unit::GetMeleeCritDamageReduction ( uint32 damage ) const

inline

Definition at line 1581 of file Unit.h.

1581{ return GetCombatRatingDamageReduction(CR_CRIT_TAKEN_MELEE, 2.2f, 33.0f, damage); }

Unit::GetCombatRatingDamageReduction

uint32 GetCombatRatingDamageReduction(CombatRating cr, float rate, float cap, uint32 damage) const

Definition: Unit.cpp:19227

◆ GetMeleeDamageReduction()

uint32 Unit::GetMeleeDamageReduction ( uint32 damage ) const

inline

Definition at line 1586 of file Unit.h.

1586{ return GetCombatRatingDamageReduction(CR_CRIT_TAKEN_MELEE, 2.0f, 100.0f, damage); }

◆ GetMeleeDamageSchoolMask()

virtual SpellSchoolMask Unit::GetMeleeDamageSchoolMask	(	WeaponAttackType	attackType = `BASE_ATTACK`,
		uint8	damageIndex = `0`
	)		const

pure virtual

Implemented in Player, and Creature.

◆ GetMeleeHitRedirectTarget()

Unit * Unit::GetMeleeHitRedirectTarget	(	Unit *	victim,
		SpellInfo const *	spellInfo = `nullptr`
	)

Definition at line 11005 of file Unit.cpp.

{
    AuraEffectList const& hitTriggerAuras = victim->GetAuraEffectsByType(SPELL_AURA_ADD_CASTER_HIT_TRIGGER);
    for (AuraEffectList::const_iterator i = hitTriggerAuras.begin(); i != hitTriggerAuras.end(); ++i)
    {
        if (Unit* magnet = (*i)->GetBase()->GetCaster())
            if (_IsValidAttackTarget(magnet, spellInfo) && magnet->IsWithinLOSInMap(this)
                    && (!spellInfo || (spellInfo->CheckExplicitTarget(this, magnet) == SPELL_CAST_OK
                                       && spellInfo->CheckTarget(this, magnet, false) == SPELL_CAST_OK)))
                if (roll_chance_i((*i)->GetAmount()))
                {
                    (*i)->GetBase()->DropCharge(AURA_REMOVE_BY_EXPIRE);
                    return magnet;
                }
    }
    return victim;
}

◆ GetMeleeRange()

float Unit::GetMeleeRange ( Unit const * target ) const

Definition at line 697 of file Unit.cpp.

{
    float range = GetCombatReach() + target->GetCombatReach() + 4.0f / 3.0f;
    return std::max(range, NOMINAL_MELEE_RANGE);
}

◆ GetMeleeReach()

float Unit::GetMeleeReach ( ) const

inline

Definition at line 1348 of file Unit.h.

1348{ float reach = m_floatValues[UNIT_FIELD_COMBATREACH]; return reach > MIN_MELEE_REACH ? reach : MIN_MELEE_REACH; }

MIN_MELEE_REACH

#define MIN_MELEE_REACH

Definition: ObjectDefines.h:47

◆ GetMinionGUID()

ObjectGuid Unit::GetMinionGUID ( ) const

inline

Definition at line 1815 of file Unit.h.

1815{ return GetGuidValue(UNIT_FIELD_SUMMON); }

UNIT_FIELD_SUMMON

@ UNIT_FIELD_SUMMON

Definition: UpdateFields.h:87

◆ GetModelForForm()

uint32 Unit::GetModelForForm ( ShapeshiftForm form ) const

Definition at line 19233 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_PLAYER)
    {
        switch (form)
        {
            case FORM_CAT:
                // Based on Hair color
                if (getRace() == RACE_NIGHTELF)
                {
                    uint8 hairColor = GetByteValue(PLAYER_BYTES, 3);
                    switch (hairColor)
                    {
                        case 7: // Violet
                        case 8:
                            return 29405;
                        case 3: // Light Blue
                            return 29406;
                        case 0: // Green
                        case 1: // Light Green
                        case 2: // Dark Green
                            return 29407;
                        case 4: // White
                            return 29408;
                        default: // original - Dark Blue
                            return 892;
                    }
                }
                // Based on Skin color
                else if (getRace() == RACE_TAUREN)
                {
                    uint8 skinColor = GetByteValue(PLAYER_BYTES, 0);
                    // Male
                    if (getGender() == GENDER_MALE)
                    {
                        switch (skinColor)
                        {
                            case 12: // White
                            case 13:
                            case 14:
                            case 18: // Completly White
                                return 29409;
                            case 9: // Light Brown
                            case 10:
                            case 11:
                                return 29410;
                            case 6: // Brown
                            case 7:
                            case 8:
                                return 29411;
                            case 0: // Dark
                            case 1:
                            case 2:
                            case 3: // Dark Grey
                            case 4:
                            case 5:
                                return 29412;
                            default: // original - Grey
                                return 8571;
                        }
                    }
                    // Female
                    else switch (skinColor)
                        {
                            case 10: // White
                                return 29409;
                            case 6: // Light Brown
                            case 7:
                                return 29410;
                            case 4: // Brown
                            case 5:
                                return 29411;
                            case 0: // Dark
                            case 1:
                            case 2:
                            case 3:
                                return 29412;
                            default: // original - Grey
                                return 8571;
                        }
                }
                else if (Player::TeamIdForRace(getRace()) == TEAM_ALLIANCE)
                    return 892;
                else
                    return 8571;
            case FORM_DIREBEAR:
            case FORM_BEAR:
                // Based on Hair color
                if (getRace() == RACE_NIGHTELF)
                {
                    uint8 hairColor = GetByteValue(PLAYER_BYTES, 3);
                    switch (hairColor)
                    {
                        case 0: // Green
                        case 1: // Light Green
                        case 2: // Dark Green
                            return 29413; // 29415?
                        case 6: // Dark Blue
                            return 29414;
                        case 4: // White
                            return 29416;
                        case 3: // Light Blue
                            return 29417;
                        default: // original - Violet
                            return 2281;
                    }
                }
                // Based on Skin color
                else if (getRace() == RACE_TAUREN)
                {
                    uint8 skinColor = GetByteValue(PLAYER_BYTES, 0);
                    // Male
                    if (getGender() == GENDER_MALE)
                    {
                        switch (skinColor)
                        {
                            case 0: // Dark (Black)
                            case 1:
                            case 2:
                                return 29418;
                            case 3: // White
                            case 4:
                            case 5:
                            case 12:
                            case 13:
                            case 14:
                                return 29419;
                            case 9: // Light Brown/Grey
                            case 10:
                            case 11:
                            case 15:
                            case 16:
                            case 17:
                                return 29420;
                            case 18: // Completly White
                                return 29421;
                            default: // original - Brown
                                return 2289;
                        }
                    }
                    // Female
                    else switch (skinColor)
                        {
                            case 0: // Dark (Black)
                            case 1:
                                return 29418;
                            case 2: // White
                            case 3:
                                return 29419;
                            case 6: // Light Brown/Grey
                            case 7:
                            case 8:
                            case 9:
                                return 29420;
                            case 10: // Completly White
                                return 29421;
                            default: // original - Brown
                                return 2289;
                        }
                }
                else if (Player::TeamIdForRace(getRace()) == TEAM_ALLIANCE)
                    return 2281;
                else
                    return 2289;
            case FORM_FLIGHT:
                if (Player::TeamIdForRace(getRace()) == TEAM_ALLIANCE)
                    return 20857;
                return 20872;
            case FORM_FLIGHT_EPIC:
                if (Player::TeamIdForRace(getRace()) == TEAM_ALLIANCE)
                    return 21243;
                return 21244;
            default:
                break;
        }
    }
 
    uint32 modelid = 0;
    SpellShapeshiftEntry const* formEntry = sSpellShapeshiftStore.LookupEntry(form);
    if (formEntry && formEntry->modelID_A)
    {
        // Take the alliance modelid as default
        if (GetTypeId() != TYPEID_PLAYER)
            return formEntry->modelID_A;
        else
        {
            if (Player::TeamIdForRace(getRace()) == TEAM_ALLIANCE)
                modelid = formEntry->modelID_A;
            else
                modelid = formEntry->modelID_H;
 
            // If the player is horde but there are no values for the horde modelid - take the alliance modelid
            if (!modelid && Player::TeamIdForRace(getRace()) == TEAM_HORDE)
                modelid = formEntry->modelID_A;
        }
    }
 
    return modelid;
}

◆ GetModelForTotem()

uint32 Unit::GetModelForTotem ( PlayerTotemType totemType )

Definition at line 19433 of file Unit.cpp.

{
    switch (getRace())
    {
        case RACE_ORC:
            {
                switch (totemType)
                {
                    case SUMMON_TYPE_TOTEM_FIRE:    // fire
                        return 30758;
                    case SUMMON_TYPE_TOTEM_EARTH:   // earth
                        return 30757;
                    case SUMMON_TYPE_TOTEM_WATER:   // water
                        return 30759;
                    case SUMMON_TYPE_TOTEM_AIR:     // air
                        return 30756;
                }
                break;
            }
        case RACE_DWARF:
            {
                switch (totemType)
                {
                    case SUMMON_TYPE_TOTEM_FIRE:    // fire
                        return 30754;
                    case SUMMON_TYPE_TOTEM_EARTH:   // earth
                        return 30753;
                    case SUMMON_TYPE_TOTEM_WATER:   // water
                        return 30755;
                    case SUMMON_TYPE_TOTEM_AIR:     // air
                        return 30736;
                }
                break;
            }
        case RACE_TROLL:
            {
                switch (totemType)
                {
                    case SUMMON_TYPE_TOTEM_FIRE:    // fire
                        return 30762;
                    case SUMMON_TYPE_TOTEM_EARTH:   // earth
                        return 30761;
                    case SUMMON_TYPE_TOTEM_WATER:   // water
                        return 30763;
                    case SUMMON_TYPE_TOTEM_AIR:     // air
                        return 30760;
                }
                break;
            }
        case RACE_TAUREN:
            {
                switch (totemType)
                {
                    case SUMMON_TYPE_TOTEM_FIRE:    // fire
                        return 4589;
                    case SUMMON_TYPE_TOTEM_EARTH:   // earth
                        return 4588;
                    case SUMMON_TYPE_TOTEM_WATER:   // water
                        return 4587;
                    case SUMMON_TYPE_TOTEM_AIR:     // air
                        return 4590;
                }
                break;
            }
        case RACE_DRAENEI:
            {
                switch (totemType)
                {
                    case SUMMON_TYPE_TOTEM_FIRE:    // fire
                        return 19074;
                    case SUMMON_TYPE_TOTEM_EARTH:   // earth
                        return 19073;
                    case SUMMON_TYPE_TOTEM_WATER:   // water
                        return 19075;
                    case SUMMON_TYPE_TOTEM_AIR:     // air
                        return 19071;
                }
                break;
            }
        default: // One standard for other races.
            {
                switch (totemType)
                {
                    case SUMMON_TYPE_TOTEM_FIRE:    // fire
                        return 4589;
                    case SUMMON_TYPE_TOTEM_EARTH:   // earth
                        return 4588;
                    case SUMMON_TYPE_TOTEM_WATER:   // water
                        return 4587;
                    case SUMMON_TYPE_TOTEM_AIR:     // air
                        return 4590;
                }
                break;
            }
    }
    return 0;
}

◆ GetModifierValue()

float Unit::GetModifierValue	(	UnitMods	unitMod,
		UnitModifierType	modifierType
	)		const

Definition at line 15145 of file Unit.cpp.

{
    if (unitMod >= UNIT_MOD_END || modifierType >= MODIFIER_TYPE_END)
    {
        LOG_ERROR("entities.unit", "attempt to access non-existing modifier value from UnitMods!");
        return 0.0f;
    }
 
    if (modifierType == TOTAL_PCT && m_auraModifiersGroup[unitMod][modifierType] <= 0.0f)
        return 0.0f;
 
    return m_auraModifiersGroup[unitMod][modifierType];
}

◆ GetMotionMaster() [1/2]

MotionMaster * Unit::GetMotionMaster ( )

inline

Definition at line 2257 of file Unit.h.

2257{ return i_motionMaster; }

◆ GetMotionMaster() [2/2]

const MotionMaster * Unit::GetMotionMaster ( ) const

inline

Definition at line 2258 of file Unit.h.

2258{ return i_motionMaster; }

◆ GetMountID()

uint32 Unit::GetMountID ( ) const

inline

Definition at line 1541 of file Unit.h.

1541{ return GetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID); }

◆ GetNativeDisplayId()

uint32 Unit::GetNativeDisplayId ( ) const

inline

Definition at line 2165 of file Unit.h.

2165{ return GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID); }

UNIT_FIELD_NATIVEDISPLAYID

@ UNIT_FIELD_NATIVEDISPLAYID

Definition: UpdateFields.h:125

◆ GetNegStat()

float Unit::GetNegStat ( Stats stat ) const

inline

Definition at line 2041 of file Unit.h.

2041{ return GetFloatValue(static_cast<uint16>(UNIT_FIELD_NEGSTAT0) + stat); }

◆ GetNextRandomRaidMemberOrPet()

Unit * Unit::GetNextRandomRaidMemberOrPet ( float radius )

Definition at line 11062 of file Unit.cpp.

{
    Player* player = nullptr;
    if (GetTypeId() == TYPEID_PLAYER)
        player = ToPlayer();
    // Should we enable this also for charmed units?
    else if (GetTypeId() == TYPEID_UNIT && IsPet())
        player = GetOwner()->ToPlayer();
 
    if (!player)
        return nullptr;
    Group* group = player->GetGroup();
    // When there is no group check pet presence
    if (!group)
    {
        // We are pet now, return owner
        if (player != this)
            return IsWithinDistInMap(player, radius) ? player : nullptr;
        Unit* pet = GetGuardianPet();
        // No pet, no group, nothing to return
        if (!pet)
            return nullptr;
        // We are owner now, return pet
        return IsWithinDistInMap(pet, radius) ? pet : nullptr;
    }
 
    std::vector<Unit*> nearMembers;
    // reserve place for players and pets because resizing vector every unit push is unefficient (vector is reallocated then)
    nearMembers.reserve(group->GetMembersCount() * 2);
 
    for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
        if (Player* Target = itr->GetSource())
        {
            if (Target != this && !IsWithinDistInMap(Target, radius))
                continue;
 
            // IsHostileTo check duel and controlled by enemy
            if (Target != this && Target->IsAlive() && !IsHostileTo(Target))
                nearMembers.push_back(Target);
 
            // Push player's pet to vector
            if (Unit* pet = Target->GetGuardianPet())
                if (pet != this && pet->IsAlive() && IsWithinDistInMap(pet, radius) && !IsHostileTo(pet))
                    nearMembers.push_back(pet);
        }
 
    if (nearMembers.empty())
        return nullptr;
 
    uint32 randTarget = urand(0, nearMembers.size() - 1);
    return nearMembers[randTarget];
}

◆ GetNpcFlags()

NPCFlags Unit::GetNpcFlags ( ) const

inline

Definition at line 1642 of file Unit.h.

1642{ return NPCFlags(GetUInt32Value(UNIT_NPC_FLAGS)); }

NPCFlags

Non Player Character flags.

Definition: Unit.h:514

◆ GetOwnedAura()

Aura * Unit::GetOwnedAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint8	reqEffMask = `0`,
		Aura *	except = `nullptr`
	)		const

Definition at line 4680 of file Unit.cpp.

{
    AuraMapBounds range = m_ownedAuras.equal_range(spellId);
    for (AuraMap::const_iterator itr = range.first; itr != range.second; ++itr)
    {
        if (((itr->second->GetEffectMask() & reqEffMask) == reqEffMask)
                && (!casterGUID || itr->second->GetCasterGUID() == casterGUID)
                && (!itemCasterGUID || itr->second->GetCastItemGUID() == itemCasterGUID)
                && (!except || except != itr->second))
        {
            return itr->second;
        }
    }
    return nullptr;
}

◆ GetOwnedAuras() [1/2]

AuraMap & Unit::GetOwnedAuras ( )

inline

Definition at line 1911 of file Unit.h.

1911{ return m_ownedAuras; }

◆ GetOwnedAuras() [2/2]

AuraMap const & Unit::GetOwnedAuras ( ) const

inline

Definition at line 1912 of file Unit.h.

1912{ return m_ownedAuras; }

◆ GetOwner()

Unit * Unit::GetOwner ( ) const

Definition at line 10548 of file Unit.cpp.

{
    if (ObjectGuid ownerGUID = GetOwnerGUID())
        return ObjectAccessor::GetUnit(*this, ownerGUID);
 
    return nullptr;
}

◆ GetOwnerGUID()

ObjectGuid Unit::GetOwnerGUID ( ) const

inline

Definition at line 1811 of file Unit.h.

1811{ return GetGuidValue(UNIT_FIELD_SUMMONEDBY); }

UNIT_FIELD_SUMMONEDBY

@ UNIT_FIELD_SUMMONEDBY

Definition: UpdateFields.h:90

◆ GetPartyMembers()

void Unit::GetPartyMembers ( std::list< Unit * > & units )

Definition at line 18851 of file Unit.cpp.

{
    Unit* owner = GetCharmerOrOwnerOrSelf();
    Group* group = nullptr;
    if (owner->GetTypeId() == TYPEID_PLAYER)
        group = owner->ToPlayer()->GetGroup();
 
    if (group)
    {
        uint8 subgroup = owner->ToPlayer()->GetSubGroup();
 
        for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
        {
            Player* Target = itr->GetSource();
 
            // IsHostileTo check duel and controlled by enemy
            if (Target && Target->IsInMap(owner) && Target->GetSubGroup() == subgroup && !IsHostileTo(Target))
            {
                if (Target->IsAlive())
                    TagUnitMap.push_back(Target);
 
                for (Unit::ControlSet::iterator iterator = Target->m_Controlled.begin(); iterator != Target->m_Controlled.end(); ++iterator)
                {
                    if (Unit* pet = *iterator)
                        if (pet->IsGuardian() && pet->IsAlive())
                            TagUnitMap.push_back(pet);
                }
            }
        }
    }
    else
    {
        if (owner->IsAlive())
            TagUnitMap.push_back(owner);
 
        for (Unit::ControlSet::iterator itr = owner->m_Controlled.begin(); itr != owner->m_Controlled.end(); ++itr)
        {
            if (Unit* pet = *itr)
                if (pet->IsGuardian() && pet->IsAlive())
                    TagUnitMap.push_back(pet);
        }
    }
}

◆ GetPetGUID()

ObjectGuid Unit::GetPetGUID ( ) const

inline

Definition at line 1821 of file Unit.h.

1821{ return m_SummonSlot[SUMMON_SLOT_PET]; }

SUMMON_SLOT_PET

#define SUMMON_SLOT_PET

Definition: Unit.h:1210

◆ GetPhaseByAuras()

uint32 Unit::GetPhaseByAuras ( ) const

Definition at line 19070 of file Unit.cpp.

{
    uint32 currentPhase = 0;
    AuraEffectList const& phases = GetAuraEffectsByType(SPELL_AURA_PHASE);
    if (!phases.empty())
        for (AuraEffectList::const_iterator itr = phases.begin(); itr != phases.end(); ++itr)
            currentPhase |= (*itr)->GetMiscValue();
 
    return currentPhase;
}

◆ GetPosStat()

float Unit::GetPosStat ( Stats stat ) const

inline

Definition at line 2040 of file Unit.h.

2040{ return GetFloatValue(static_cast<uint16>(UNIT_FIELD_POSSTAT0) + stat); }

◆ GetPower()

uint32 Unit::GetPower ( Powers power ) const

inline

Definition at line 1459 of file Unit.h.

1459{ return GetUInt32Value(static_cast<uint16>(UNIT_FIELD_POWER1) + power); }

UNIT_FIELD_POWER1

@ UNIT_FIELD_POWER1

Definition: UpdateFields.h:97

◆ GetPowerPct()

float Unit::GetPowerPct ( Powers power ) const

inline

Definition at line 1449 of file Unit.h.

1449{ return GetMaxPower(power) ? 100.f * GetPower(power) / GetMaxPower(power) : 0.0f; }

Unit::GetMaxPower

uint32 GetMaxPower(Powers power) const

Definition: Unit.h:1460

Unit::GetPower

uint32 GetPower(Powers power) const

Definition: Unit.h:1459

◆ getPowerType()

Powers Unit::getPowerType ( ) const

inline

Definition at line 1457 of file Unit.h.

1457{ return Powers(GetByteValue(UNIT_FIELD_BYTES_0, 3)); }

Powers

Definition: SharedDefines.h:240

◆ GetPowerTypeByAuraGroup()

Powers Unit::GetPowerTypeByAuraGroup ( UnitMods unitMod ) const

Definition at line 15263 of file Unit.cpp.

{
    switch (unitMod)
    {
        case UNIT_MOD_RAGE:
            return POWER_RAGE;
        case UNIT_MOD_FOCUS:
            return POWER_FOCUS;
        case UNIT_MOD_ENERGY:
            return POWER_ENERGY;
        case UNIT_MOD_HAPPINESS:
            return POWER_HAPPINESS;
        case UNIT_MOD_RUNE:
            return POWER_RUNE;
        case UNIT_MOD_RUNIC_POWER:
            return POWER_RUNIC_POWER;
        default:
        case UNIT_MOD_MANA:
            return POWER_MANA;
    }
}

◆ GetPPMProcChance()

float Unit::GetPPMProcChance	(	uint32	WeaponSpeed,
		float	PPM,
		SpellInfo const *	spellProto
	)		const

Definition at line 13355 of file Unit.cpp.

{
    // proc per minute chance calculation
    if (PPM <= 0)
        return 0.0f;
 
    // Apply chance modifer aura
    if (spellProto)
        if (Player* modOwner = GetSpellModOwner())
            modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_PROC_PER_MINUTE, PPM);
 
    return floor((WeaponSpeed * PPM) / 600.0f);   // result is chance in percents (probability = Speed_in_sec * (PPM / 60))
}

◆ GetProcAurasTriggeredOnEvent()

void Unit::GetProcAurasTriggeredOnEvent	(	std::list< AuraApplication * > &	aurasTriggeringProc,
		std::list< AuraApplication * > *	procAuras,
		ProcEventInfo	eventInfo
	)

Definition at line 16617 of file Unit.cpp.

{
    // use provided list of auras which can proc
    if (procAuras)
    {
        for (std::list<AuraApplication*>::iterator itr = procAuras->begin(); itr != procAuras->end(); ++itr)
        {
            ASSERT((*itr)->GetTarget() == this);
            if (!(*itr)->GetRemoveMode())
                if ((*itr)->GetBase()->IsProcTriggeredOnEvent(*itr, eventInfo))
                {
                    (*itr)->GetBase()->PrepareProcToTrigger(*itr, eventInfo);
                    aurasTriggeringProc.push_back(*itr);
                }
        }
    }
    // or generate one on our own
    else
    {
        for (AuraApplicationMap::iterator itr = GetAppliedAuras().begin(); itr != GetAppliedAuras().end(); ++itr)
        {
            if (itr->second->GetBase()->IsProcTriggeredOnEvent(itr->second, eventInfo))
            {
                itr->second->GetBase()->PrepareProcToTrigger(itr->second, eventInfo);
                aurasTriggeringProc.push_back(itr->second);
            }
        }
    }
}

◆ getRace()

uint8 Unit::getRace ( bool original = false ) const

Definition at line 21022 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_PLAYER)
    {
        if (original)
            return m_realRace;
        else
            return m_race;
    }
 
    return GetByteValue(UNIT_FIELD_BYTES_0, 0);
}

◆ getRaceMask()

uint32 Unit::getRaceMask ( ) const

inline

Definition at line 1423 of file Unit.h.

1423{ return 1 << (getRace(true) - 1); }

◆ GetRandomContactPoint()

bool Unit::GetRandomContactPoint	(	Unit const *	target,
		float &	x,
		float &	y,
		float &	z,
		bool	force = `false`
	)		const

Definition at line 718 of file Unit.cpp.

{
    float combat_reach = GetCombatReach();
    if (combat_reach < 0.1f) // sometimes bugged for players
        combat_reach = DEFAULT_COMBAT_REACH;
 
    uint32 attacker_number = getAttackers().size();
    if (attacker_number > 0)
        --attacker_number;
    Creature const* c = obj->ToCreature();
    if (c)
        if (c->isWorldBoss() || c->IsDungeonBoss() || (obj->IsPet() && const_cast<Unit*>(obj)->ToPet()->isControlled()))
            attacker_number = 0; // pussywizard: pets and bosses just come to target from their angle
 
    GetNearPoint(obj, x, y, z, isMoving() ? (obj->GetCombatReach() > 7.75f ? obj->GetCombatReach() - 7.5f : 0.25f) : obj->GetCombatReach(), 0.0f,
                 GetAngle(obj) + (attacker_number ? (static_cast<float>(M_PI / 2) - static_cast<float>(M_PI) * (float)rand_norm()) * float(attacker_number) / combat_reach * 0.3f : 0));
 
    // pussywizard
    if (std::fabs(this->GetPositionZ() - z) > this->GetCollisionHeight() || !IsWithinLOS(x, y, z))
    {
        x = this->GetPositionX();
        y = this->GetPositionY();
        z = this->GetPositionZ();
        obj->UpdateAllowedPositionZ(x, y, z);
    }
    float maxDist = GetMeleeRange(obj);
    if (GetExactDistSq(x, y, z) >= maxDist * maxDist)
    {
        if (force)
        {
            x = this->GetPositionX();
            y = this->GetPositionY();
            z = this->GetPositionZ();
            return true;
        }
        return false;
    }
    return true;
}

◆ GetRangedCritChanceReduction()

float Unit::GetRangedCritChanceReduction ( ) const

inline

Definition at line 1577 of file Unit.h.

1577{ return GetCombatRatingReduction(CR_CRIT_TAKEN_RANGED); }

◆ GetRangedCritDamageReduction()

uint32 Unit::GetRangedCritDamageReduction ( uint32 damage ) const

inline

Definition at line 1582 of file Unit.h.

1582{ return GetCombatRatingDamageReduction(CR_CRIT_TAKEN_RANGED, 2.2f, 33.0f, damage); }

◆ GetRangedDamageReduction()

uint32 Unit::GetRangedDamageReduction ( uint32 damage ) const

inline

Definition at line 1587 of file Unit.h.

1587{ return GetCombatRatingDamageReduction(CR_CRIT_TAKEN_RANGED, 2.0f, 100.0f, damage); }

◆ GetReactionTo()

ReputationRank Unit::GetReactionTo	(	Unit const *	target,
		bool	checkOriginalFaction = `false`
	)		const

Definition at line 10025 of file Unit.cpp.

{
    // always friendly to self
    if (this == target)
        return REP_FRIENDLY;
 
    // always friendly to charmer or owner
    if (GetCharmerOrOwnerOrSelf() == target->GetCharmerOrOwnerOrSelf())
        return REP_FRIENDLY;
 
    Player const* selfPlayerOwner = GetAffectingPlayer();
    Player const* targetPlayerOwner = target->GetAffectingPlayer();
 
    // check forced reputation to support SPELL_AURA_FORCE_REACTION
    if (selfPlayerOwner)
    {
        if (FactionTemplateEntry const* targetFactionTemplateEntry = target->GetFactionTemplateEntry())
            if (ReputationRank const* repRank = selfPlayerOwner->GetReputationMgr().GetForcedRankIfAny(targetFactionTemplateEntry))
                return *repRank;
    }
    else if (targetPlayerOwner)
    {
        if (FactionTemplateEntry const* selfFactionTemplateEntry = GetFactionTemplateEntry())
            if (ReputationRank const* repRank = targetPlayerOwner->GetReputationMgr().GetForcedRankIfAny(selfFactionTemplateEntry))
                return *repRank;
    }
 
    if (HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
    {
        if (target->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
        {
            if (selfPlayerOwner && targetPlayerOwner)
            {
                // always friendly to other unit controlled by player, or to the player himself
                if (selfPlayerOwner == targetPlayerOwner)
                    return REP_FRIENDLY;
 
                // duel - always hostile to opponent
                if (selfPlayerOwner->duel && selfPlayerOwner->duel->Opponent == targetPlayerOwner && selfPlayerOwner->duel->State == DUEL_STATE_IN_PROGRESS)
                    return REP_HOSTILE;
 
                // same group - checks dependant only on our faction - skip FFA_PVP for example
                if (selfPlayerOwner->IsInRaidWith(targetPlayerOwner))
                    return REP_FRIENDLY; // return true to allow config option AllowTwoSide.Interaction.Group to work
                // however client seems to allow mixed group parties, because in 13850 client it works like:
                // return GetFactionReactionTo(GetFactionTemplateEntry(), target);
            }
 
            // check FFA_PVP
            if (IsFFAPvP() && target->IsFFAPvP())
                return REP_HOSTILE;
 
            if (selfPlayerOwner)
            {
                if (FactionTemplateEntry const* targetFactionTemplateEntry = target->GetFactionTemplateEntry())
                {
                    if (ReputationRank const* repRank = selfPlayerOwner->GetReputationMgr().GetForcedRankIfAny(targetFactionTemplateEntry))
                        return *repRank;
                    if (!selfPlayerOwner->HasUnitFlag2(UNIT_FLAG2_IGNORE_REPUTATION))
                    {
                        if (FactionEntry const* targetFactionEntry = sFactionStore.LookupEntry(targetFactionTemplateEntry->faction))
                        {
                            if (targetFactionEntry->CanHaveReputation())
                            {
                                // check contested flags
                                if (targetFactionTemplateEntry->factionFlags & FACTION_TEMPLATE_FLAG_ATTACK_PVP_ACTIVE_PLAYERS
                                        && selfPlayerOwner->HasPlayerFlag(PLAYER_FLAGS_CONTESTED_PVP))
                                    return REP_HOSTILE;
 
                                // if faction has reputation, hostile state depends only from AtWar state
                                if (selfPlayerOwner->GetReputationMgr().IsAtWar(targetFactionEntry))
                                    return REP_HOSTILE;
                                return REP_FRIENDLY;
                            }
                        }
                    }
                }
            }
        }
    }
 
    ReputationRank repRank = REP_HATED;
    if (!sScriptMgr->IfNormalReaction(this, target, repRank))
    {
        return ReputationRank(repRank);
    }
 
    FactionTemplateEntry const* factionTemplateEntry = nullptr;
    if (checkOriginalFaction)
    {
        if (GetTypeId() == TYPEID_PLAYER)
        {
            if (ChrRacesEntry const* rEntry = sChrRacesStore.LookupEntry(getRace()))
            {
                factionTemplateEntry = sFactionTemplateStore.LookupEntry(rEntry->FactionID);
            }
        }
        else
        {
            Unit* owner = GetOwner();
            if (HasUnitTypeMask(UNIT_MASK_MINION) && owner)
            {
                factionTemplateEntry = sFactionTemplateStore.LookupEntry(owner->GetFaction());
            }
            else if (CreatureTemplate const* cinfo = ToCreature()->GetCreatureTemplate())
            {
                factionTemplateEntry = sFactionTemplateStore.LookupEntry(cinfo->faction);
            }
        }
    }
 
    if (!factionTemplateEntry)
    {
        factionTemplateEntry = GetFactionTemplateEntry();
    }
 
    // do checks dependant only on our faction
    return GetFactionReactionTo(factionTemplateEntry, target);
}

◆ GetRedirectThreatPercent()

uint32 Unit::GetRedirectThreatPercent ( )

inline

Definition at line 2342 of file Unit.h.

2342{ return _redirectThreatInfo.GetThreatPct(); }

RedirectThreatInfo::GetThreatPct

uint32 GetThreatPct() const

Definition: Unit.h:954

◆ GetRedirectThreatTarget()

Unit * Unit::GetRedirectThreatTarget ( ) const

Definition at line 19531 of file Unit.cpp.

{
    return _redirectThreatInfo.GetTargetGUID() ? ObjectAccessor::GetUnit(*this, _redirectThreatInfo.GetTargetGUID()) : nullptr;
}

◆ GetResistance() [1/2]

uint32 Unit::GetResistance ( SpellSchoolMask mask ) const

Definition at line 20323 of file Unit.cpp.

{
    int32 resist = -1;
    for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
        if (mask & (1 << i) && (resist < 0 || resist > int32(GetResistance(SpellSchools(i)))))
            resist = int32(GetResistance(SpellSchools(i)));
 
    // resist value will never be negative here
    return uint32(resist);
}

◆ GetResistance() [2/2]

uint32 Unit::GetResistance ( SpellSchools school ) const

inline

Definition at line 1433 of file Unit.h.

1433{ return GetUInt32Value(static_cast<uint16>(UNIT_FIELD_RESISTANCES) + school); }

UNIT_FIELD_RESISTANCES

@ UNIT_FIELD_RESISTANCES

Definition: UpdateFields.h:156

◆ GetResistanceBuffMods()

float Unit::GetResistanceBuffMods	(	SpellSchools	school,
		bool	positive
	)		const

inline

Definition at line 2022 of file Unit.h.

2022{ return GetFloatValue(positive ? static_cast<uint16>(UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE) + school : static_cast<uint16>(UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE) + + school); }

◆ GetShapeshiftForm()

ShapeshiftForm Unit::GetShapeshiftForm ( ) const

inline

Definition at line 2068 of file Unit.h.

2068{ return ShapeshiftForm(GetByteValue(UNIT_FIELD_BYTES_2, 3)); }

◆ GetSharedVisionList()

SharedVisionList const & Unit::GetSharedVisionList ( )

inline

Definition at line 1886 of file Unit.h.

1886{ return m_sharedVision; }

◆ GetSheath()

SheathState Unit::GetSheath ( ) const

inline

Definition at line 1489 of file Unit.h.

1489{ return SheathState(GetByteValue(UNIT_FIELD_BYTES_2, 0)); }

SheathState

Definition: Unit.h:125

◆ GetShieldBlockValue() [1/2]

virtual uint32 Unit::GetShieldBlockValue ( ) const

pure virtual

Implemented in Creature, and Player.

◆ GetShieldBlockValue() [2/2]

uint32 Unit::GetShieldBlockValue	(	uint32	soft_cap,
		uint32	hard_cap
	)		const

inline

Definition at line 1619 of file Unit.h.

    {
        uint32 value = GetShieldBlockValue();
        if (value >= hard_cap)
        {
            value = (soft_cap + hard_cap) / 2;
        }
        else if (value > soft_cap)
        {
            value = soft_cap + ((value - soft_cap) / 2);
        }
 
        return value;
    }

◆ GetSingleCastAuras() [1/2]

AuraList & Unit::GetSingleCastAuras ( )

inline

Definition at line 1965 of file Unit.h.

1965{ return m_scAuras; }

Unit::m_scAuras

AuraList m_scAuras

Definition: Unit.h:2503

◆ GetSingleCastAuras() [2/2]

AuraList const & Unit::GetSingleCastAuras ( ) const

inline

Definition at line 1966 of file Unit.h.

1966{ return m_scAuras; }

◆ GetSpeed()

float Unit::GetSpeed ( UnitMoveType mtype ) const

Definition at line 14296 of file Unit.cpp.

{
    return m_speed_rate[mtype] * (IsControlledByPlayer() ? playerBaseMoveSpeed[mtype] : baseMoveSpeed[mtype]);
}

◆ GetSpeedRate()

float Unit::GetSpeedRate ( UnitMoveType mtype ) const

inline

Definition at line 2243 of file Unit.h.

2243{ return m_speed_rate[mtype]; }

◆ GetSpellCritChanceReduction()

float Unit::GetSpellCritChanceReduction ( ) const

inline

Definition at line 1578 of file Unit.h.

1578{ return GetCombatRatingReduction(CR_CRIT_TAKEN_SPELL); }

◆ GetSpellCritDamageReduction()

uint32 Unit::GetSpellCritDamageReduction ( uint32 damage ) const

inline

Definition at line 1583 of file Unit.h.

1583{ return GetCombatRatingDamageReduction(CR_CRIT_TAKEN_SPELL, 2.2f, 33.0f, damage); }

◆ GetSpellDamageReduction()

uint32 Unit::GetSpellDamageReduction ( uint32 damage ) const

inline

Definition at line 1588 of file Unit.h.

1588{ return GetCombatRatingDamageReduction(CR_CRIT_TAKEN_SPELL, 2.0f, 100.0f, damage); }

◆ GetSpellMaxRangeForTarget()

float Unit::GetSpellMaxRangeForTarget	(	Unit const *	target,
		SpellInfo const *	spellInfo
	)		const

Definition at line 15004 of file Unit.cpp.

{
    if (!spellInfo->RangeEntry)
    {
        return 0;
    }
 
    if (spellInfo->RangeEntry->RangeMax[1] == spellInfo->RangeEntry->RangeMax[0])
    {
        return spellInfo->GetMaxRange();
    }
 
    if (!target)
    {
        return spellInfo->GetMaxRange(true);
    }
 
    return spellInfo->GetMaxRange(!IsHostileTo(target));
}

◆ GetSpellMinRangeForTarget()

float Unit::GetSpellMinRangeForTarget	(	Unit const *	target,
		SpellInfo const *	spellInfo
	)		const

Definition at line 15024 of file Unit.cpp.

{
    if (!spellInfo->RangeEntry)
    {
        return 0;
    }
 
    if (spellInfo->RangeEntry->RangeMin[1] == spellInfo->RangeEntry->RangeMin[0])
    {
        return spellInfo->GetMinRange();
    }
 
    return spellInfo->GetMinRange(!IsHostileTo(target));
}

◆ GetSpellModOwner()

Player * Unit::GetSpellModOwner ( ) const

Definition at line 16681 of file Unit.cpp.

{
    if (Player* player = const_cast<Unit*>(this)->ToPlayer())
        return player;
 
    if (Unit* owner = GetOwner())
        if (Player* player = owner->ToPlayer())
            return player;
 
    return nullptr;
}

◆ GetSpellSchoolByAuraGroup()

SpellSchools Unit::GetSpellSchoolByAuraGroup ( UnitMods unitMod ) const

Definition at line 15202 of file Unit.cpp.

{
    SpellSchools school = SPELL_SCHOOL_NORMAL;
 
    switch (unitMod)
    {
        case UNIT_MOD_RESISTANCE_HOLY:
            school = SPELL_SCHOOL_HOLY;
            break;
        case UNIT_MOD_RESISTANCE_FIRE:
            school = SPELL_SCHOOL_FIRE;
            break;
        case UNIT_MOD_RESISTANCE_NATURE:
            school = SPELL_SCHOOL_NATURE;
            break;
        case UNIT_MOD_RESISTANCE_FROST:
            school = SPELL_SCHOOL_FROST;
            break;
        case UNIT_MOD_RESISTANCE_SHADOW:
            school = SPELL_SCHOOL_SHADOW;
            break;
        case UNIT_MOD_RESISTANCE_ARCANE:
            school = SPELL_SCHOOL_ARCANE;
            break;
 
        default:
            break;
    }
 
    return school;
}

◆ getStandState()

uint8 Unit::getStandState ( ) const

inline

Definition at line 1532 of file Unit.h.

1532{ return GetByteValue(UNIT_FIELD_BYTES_1, 0); }

UNIT_FIELD_BYTES_1

@ UNIT_FIELD_BYTES_1

Definition: UpdateFields.h:131

◆ GetStat()

float Unit::GetStat ( Stats stat ) const

inline

Definition at line 1428 of file Unit.h.

1428{ return float(GetUInt32Value(static_cast<uint16>(UNIT_FIELD_STAT0) + stat)); }

UNIT_FIELD_STAT0

@ UNIT_FIELD_STAT0

Definition: UpdateFields.h:141

◆ GetStatByAuraGroup()

Stats Unit::GetStatByAuraGroup ( UnitMods unitMod ) const

Definition at line 15234 of file Unit.cpp.

{
    Stats stat = STAT_STRENGTH;
 
    switch (unitMod)
    {
        case UNIT_MOD_STAT_STRENGTH:
            stat = STAT_STRENGTH;
            break;
        case UNIT_MOD_STAT_AGILITY:
            stat = STAT_AGILITY;
            break;
        case UNIT_MOD_STAT_STAMINA:
            stat = STAT_STAMINA;
            break;
        case UNIT_MOD_STAT_INTELLECT:
            stat = STAT_INTELLECT;
            break;
        case UNIT_MOD_STAT_SPIRIT:
            stat = STAT_SPIRIT;
            break;
 
        default:
            break;
    }
 
    return stat;
}

◆ GetTarget()

ObjectGuid Unit::GetTarget ( ) const

inline

Definition at line 2428 of file Unit.h.

2428{ return GetGuidValue(UNIT_FIELD_TARGET); }

UNIT_FIELD_TARGET

@ UNIT_FIELD_TARGET

Definition: UpdateFields.h:92

◆ GetThreatMgr() [1/2]

ThreatMgr & Unit::GetThreatMgr ( )

inline

Definition at line 2142 of file Unit.h.

2142{ return m_ThreatMgr; }

◆ GetThreatMgr() [2/2]

ThreatMgr const & Unit::GetThreatMgr ( ) const

inline

Definition at line 2143 of file Unit.h.

2143{ return m_ThreatMgr; }

◆ GetTotalAttackPowerValue()

float Unit::GetTotalAttackPowerValue	(	WeaponAttackType	attType,
		Unit *	pVictim = `nullptr`
	)		const

Definition at line 15285 of file Unit.cpp.

{
    if (attType == RANGED_ATTACK)
    {
        int32 ap = GetInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER) + GetInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER_MODS);
        if( victim )
            ap += victim->GetTotalAuraModifier(SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
 
        if (ap < 0)
            return 0.0f;
        return ap * (1.0f + GetFloatValue(UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER));
    }
    else
    {
        int32 ap = GetInt32Value(UNIT_FIELD_ATTACK_POWER) + GetInt32Value(UNIT_FIELD_ATTACK_POWER_MODS);
        if( victim )
            ap += victim->GetTotalAuraModifier(SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS);
 
        if (ap < 0)
            return 0.0f;
        return ap * (1.0f + GetFloatValue(UNIT_FIELD_ATTACK_POWER_MULTIPLIER));
    }
}

◆ GetTotalAuraModifier()

int32 Unit::GetTotalAuraModifier ( AuraType auratype ) const

Definition at line 5810 of file Unit.cpp.

{
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    if (mTotalAuraList.empty())
        return 0;
 
    int32 modifier = 0;
 
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        modifier += (*i)->GetAmount();
 
    return modifier;
}

◆ GetTotalAuraModifierAreaExclusive()

int32 Unit::GetTotalAuraModifierAreaExclusive ( AuraType auratype ) const

Definition at line 5790 of file Unit.cpp.

{
    int32 modifier = 0;
    int32 areaModifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if ((*i)->GetSpellInfo()->HasAreaAuraEffect())
        {
            if (areaModifier < (*i)->GetAmount())
                areaModifier = (*i)->GetAmount();
        }
        else
            modifier += (*i)->GetAmount();
    }
 
    return modifier + areaModifier;
}

◆ GetTotalAuraModifierByAffectMask()

int32 Unit::GetTotalAuraModifierByAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

Definition at line 5966 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if ((*i)->IsAffectedOnSpell(affectedSpell))
            modifier += (*i)->GetAmount();
 
    return modifier;
}

◆ GetTotalAuraModifierByMiscMask()

int32 Unit::GetTotalAuraModifierByMiscMask	(	AuraType	auratype,
		uint32	misc_mask
	)		const

Definition at line 5861 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if ((*i)->GetMiscValue()& misc_mask)
            modifier += (*i)->GetAmount();
    }
    return modifier;
}

◆ GetTotalAuraModifierByMiscValue()

int32 Unit::GetTotalAuraModifierByMiscValue	(	AuraType	auratype,
		int32	misc_value
	)		const

Definition at line 5914 of file Unit.cpp.

{
    int32 modifier = 0;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if ((*i)->GetMiscValue() == misc_value)
            modifier += (*i)->GetAmount();
 
    return modifier;
}

◆ GetTotalAuraModValue()

float Unit::GetTotalAuraModValue ( UnitMods unitMod ) const

Definition at line 15175 of file Unit.cpp.

{
    if (unitMod >= UNIT_MOD_END)
    {
        LOG_ERROR("entities.unit", "attempt to access non-existing UnitMods in GetTotalAuraModValue()!");
        return 0.0f;
    }
 
    if (m_auraModifiersGroup[unitMod][TOTAL_PCT] <= 0.0f)
        return 0.0f;
 
    float value = m_auraModifiersGroup[unitMod][BASE_VALUE];
    value *= m_auraModifiersGroup[unitMod][BASE_PCT];
    value += m_auraModifiersGroup[unitMod][TOTAL_VALUE];
    value *= m_auraModifiersGroup[unitMod][TOTAL_PCT];
 
    return value;
}

◆ GetTotalAuraMultiplier()

float Unit::GetTotalAuraMultiplier ( AuraType auratype ) const

Definition at line 5824 of file Unit.cpp.

{
    float multiplier = 1.0f;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        AddPct(multiplier, (*i)->GetAmount());
 
    return multiplier;
}

◆ GetTotalAuraMultiplierByAffectMask()

float Unit::GetTotalAuraMultiplierByAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

Definition at line 5978 of file Unit.cpp.

{
    float multiplier = 1.0f;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if ((*i)->IsAffectedOnSpell(affectedSpell))
            AddPct(multiplier, (*i)->GetAmount());
 
    return multiplier;
}

◆ GetTotalAuraMultiplierByMiscMask()

float Unit::GetTotalAuraMultiplierByMiscMask	(	AuraType	auratype,
		uint32	misc_mask
	)		const

Definition at line 5874 of file Unit.cpp.

{
    float multiplier = 1.0f;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if (((*i)->GetMiscValue() & misc_mask))
            AddPct(multiplier, (*i)->GetAmount());
 
    return multiplier;
}

◆ GetTotalAuraMultiplierByMiscValue()

float Unit::GetTotalAuraMultiplierByMiscValue	(	AuraType	auratype,
		int32	misc_value
	)		const

Definition at line 5926 of file Unit.cpp.

{
    float multiplier = 1.0f;
 
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if ((*i)->GetMiscValue() == misc_value)
            AddPct(multiplier, (*i)->GetAmount());
 
    return multiplier;
}

◆ GetTotalStatValue()

float Unit::GetTotalStatValue	(	Stats	stat,
		float	additionalValue = `0.0f`
	)		const

Definition at line 15159 of file Unit.cpp.

{
    UnitMods unitMod = UnitMods(static_cast<uint16>(UNIT_MOD_STAT_START) + stat);
 
    if (m_auraModifiersGroup[unitMod][TOTAL_PCT] <= 0.0f)
        return 0.0f;
 
    // value = ((base_value * base_pct) + total_value) * total_pct
    float value  = m_auraModifiersGroup[unitMod][BASE_VALUE] + GetCreateStat(stat);
    value *= m_auraModifiersGroup[unitMod][BASE_PCT];
    value += m_auraModifiersGroup[unitMod][TOTAL_VALUE] + additionalValue;
    value *= m_auraModifiersGroup[unitMod][TOTAL_PCT];
 
    return value;
}

◆ getTransForm()

uint32 Unit::getTransForm ( ) const

inline

Definition at line 2169 of file Unit.h.

2169{ return m_transform;}

◆ GetTransGUID()

ObjectGuid Unit::GetTransGUID ( ) const

overridevirtual

Reimplemented from WorldObject.

Definition at line 18788 of file Unit.cpp.

{
    if (GetVehicle())
        return GetVehicleBase()->GetGUID();
 
    if (GetTransport())
        return GetTransport()->GetGUID();
 
    return ObjectGuid::Empty;
}

◆ GetUnitBlockChance()

float Unit::GetUnitBlockChance ( ) const

Definition at line 3643 of file Unit.cpp.

{
    if (Player const* player = ToPlayer())
    {
        if (player->CanBlock())
        {
            Item* tmpitem = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
            if (tmpitem && !tmpitem->IsBroken() && tmpitem->GetTemplate()->Block)
                return GetFloatValue(PLAYER_BLOCK_PERCENTAGE);
        }
        // is player but has no block ability or no not broken shield equipped
        return 0.0f;
    }
    else
    {
        if (ToCreature()->IsTotem())
            return 0.0f;
        else
        {
            float block = 5.0f;
            block += GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_PERCENT);
            return block > 0.0f ? block : 0.0f;
        }
    }
}

◆ GetUnitCriticalChance()

float Unit::GetUnitCriticalChance	(	WeaponAttackType	attackType,
		Unit const *	victim
	)		const

Definition at line 3669 of file Unit.cpp.

{
    float crit;
 
    if (GetTypeId() == TYPEID_PLAYER)
    {
        switch (attackType)
        {
            case BASE_ATTACK:
                crit = GetFloatValue(PLAYER_CRIT_PERCENTAGE);
                break;
            case OFF_ATTACK:
                crit = GetFloatValue(PLAYER_OFFHAND_CRIT_PERCENTAGE);
                break;
            case RANGED_ATTACK:
                crit = GetFloatValue(PLAYER_RANGED_CRIT_PERCENTAGE);
                break;
            // Just for good manner
            default:
                crit = 0.0f;
                break;
        }
    }
    else
    {
        crit = 5.0f;
        crit += GetTotalAuraModifier(SPELL_AURA_MOD_WEAPON_CRIT_PERCENT);
        crit += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_PCT);
    }
 
    // flat aura mods
    if (attackType == RANGED_ATTACK)
        crit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_CHANCE);
    else
        crit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_CHANCE);
 
    AuraEffectList const& mTotalAuraList = victim->GetAuraEffectsByType(SPELL_AURA_MOD_CRIT_CHANCE_FOR_CASTER);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
    {
        if (GetGUID() != (*i)->GetCasterGUID())
            continue;
 
        crit += (*i)->GetAmount();
    }
 
    // reduce crit chance from Rating for players
    if (attackType != RANGED_ATTACK)
        Unit::ApplyResilience(victim, &crit, nullptr, false, CR_CRIT_TAKEN_MELEE);
    else
        Unit::ApplyResilience(victim, &crit, nullptr, false, CR_CRIT_TAKEN_RANGED);
 
    // Apply crit chance from defence skill
    crit += (int32(GetMaxSkillValueForLevel(victim)) - int32(victim->GetDefenseSkillValue(this))) * 0.04f;
 
    // xinef: SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE should be calculated at the end
    crit += victim->GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
 
    if (crit < 0.0f)
        crit = 0.0f;
    return crit;
}

◆ GetUnitDodgeChance()

float Unit::GetUnitDodgeChance ( ) const

Definition at line 3581 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_PLAYER)
        return ToPlayer()->GetRealDodge(); //GetFloatValue(PLAYER_DODGE_PERCENTAGE);
    else
    {
        if (ToCreature()->IsTotem())
            return 0.0f;
        else
        {
            float dodge = ToCreature()->isWorldBoss() ? 5.85f : 5.0f; // Xinef: bosses should have 6.5% dodge (5.9 + 0.6 from defense skill difference)
            dodge += GetTotalAuraModifier(SPELL_AURA_MOD_DODGE_PERCENT);
            return dodge > 0.0f ? dodge : 0.0f;
        }
    }
}

◆ GetUnitFlags()

UnitFlags Unit::GetUnitFlags ( ) const

inline

Definition at line 1477 of file Unit.h.

1477{ return UnitFlags(GetUInt32Value(UNIT_FIELD_FLAGS)); }

UnitFlags

Definition: Unit.h:446

◆ GetUnitFlags2()

UnitFlags2 Unit::GetUnitFlags2 ( ) const

inline

Definition at line 1483 of file Unit.h.

1483{ return UnitFlags2(GetUInt32Value(UNIT_FIELD_FLAGS_2)); }

UNIT_FIELD_FLAGS_2

@ UNIT_FIELD_FLAGS_2

Definition: UpdateFields.h:118

UnitFlags2

Definition: Unit.h:486

◆ GetUnitMeleeSkill()

uint32 Unit::GetUnitMeleeSkill ( Unit const * target = nullptr ) const

inline

Definition at line 1633 of file Unit.h.

1633{ return (target ? getLevelForTarget(target) : getLevel()) * 5; }

◆ GetUnitMissChance()

float Unit::GetUnitMissChance ( WeaponAttackType attType ) const

Definition at line 3628 of file Unit.cpp.

{
    float miss_chance = 5.00f;
 
    if (Player const* player = ToPlayer())
        miss_chance += player->GetMissPercentageFromDefence();
 
    if (attType == RANGED_ATTACK)
        miss_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_HIT_CHANCE);
    else
        miss_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE);
 
    return miss_chance;
}

◆ GetUnitMovementFlags()

uint32 Unit::GetUnitMovementFlags ( ) const

inline

Definition at line 2270 of file Unit.h.

2270{ return m_movementInfo.flags; }

◆ GetUnitParryChance()

float Unit::GetUnitParryChance ( ) const

Definition at line 3598 of file Unit.cpp.

{
    float chance = 0.0f;
 
    if (Player const* player = ToPlayer())
    {
        if (player->CanParry())
        {
            Item* tmpitem = player->GetWeaponForAttack(BASE_ATTACK, true);
            if (!tmpitem)
                tmpitem = player->GetWeaponForAttack(OFF_ATTACK, true);
 
            if (tmpitem)
                chance = player->GetRealParry(); //GetFloatValue(PLAYER_PARRY_PERCENTAGE);
        }
    }
    else if (GetTypeId() == TYPEID_UNIT)
    {
        if (ToCreature()->isWorldBoss())
            chance = 13.4f; // + 0.6 by skill diff
        else if (GetCreatureType() == CREATURE_TYPE_HUMANOID)
            chance = 5.0f;
 
        // Xinef: if aura is present, type should not matter
        chance += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT);
    }
 
    return chance > 0.0f ? chance : 0.0f;
}

◆ GetUnitState()

uint32 Unit::GetUnitState ( ) const

inline

Definition at line 1400 of file Unit.h.

1400{ return m_state; }

◆ GetUnitTypeMask()

uint32 Unit::GetUnitTypeMask ( ) const

inline

Definition at line 1409 of file Unit.h.

1409{ return m_unitTypeMask; }

◆ GetVehicle()

Vehicle * Unit::GetVehicle ( ) const

inline

Definition at line 2349 of file Unit.h.

2349{ return m_vehicle; }

◆ GetVehicleBase()

Unit * Unit::GetVehicleBase ( ) const

Definition at line 18774 of file Unit.cpp.

{
    return m_vehicle ? m_vehicle->GetBase() : nullptr;
}

◆ GetVehicleCreatureBase()

Creature * Unit::GetVehicleCreatureBase ( ) const

Definition at line 18779 of file Unit.cpp.

{
    if (Unit* veh = GetVehicleBase())
        if (Creature* c = veh->ToCreature())
            return c;
 
    return nullptr;
}

◆ GetVehicleKit()

Vehicle * Unit::GetVehicleKit ( ) const

inline

Definition at line 2348 of file Unit.h.

2348{ return m_vehicleKit; }

◆ GetVictim()

Unit * Unit::GetVictim ( ) const

inline

Definition at line 1386 of file Unit.h.

1386{ return m_attacking; }

◆ GetVisibleAura()

AuraApplication * Unit::GetVisibleAura ( uint8 slot )

inline

Definition at line 2149 of file Unit.h.

    {
        VisibleAuraMap::iterator itr = m_visibleAuras.find(slot);
        if (itr != m_visibleAuras.end())
            return itr->second;
        return nullptr;
    }

◆ GetVisibleAuras()

VisibleAuraMap const * Unit::GetVisibleAuras ( )

inline

Definition at line 2148 of file Unit.h.

2148{ return &m_visibleAuras; }

◆ GetWeaponDamageRange()

float Unit::GetWeaponDamageRange	(	WeaponAttackType	attType,
		WeaponDamageRange	type,
		uint8	damageIndex = `0`
	)		const

Definition at line 15309 of file Unit.cpp.

{
    if (attType == OFF_ATTACK && !haveOffhandWeapon())
        return 0.0f;
 
    return m_weaponDamage[attType][type][damageIndex];
}

◆ GetWeaponProcChance()

float Unit::GetWeaponProcChance ( ) const

Definition at line 13344 of file Unit.cpp.

{
    // normalized proc chance for weapon attack speed
    // (odd formula...)
    if (isAttackReady(BASE_ATTACK))
        return (GetAttackTime(BASE_ATTACK) * 1.8f / 1000.0f);
    else if (haveOffhandWeapon() && isAttackReady(OFF_ATTACK))
        return (GetAttackTime(OFF_ATTACK) * 1.6f / 1000.0f);
    return 0;
}

◆ GetWeaponSkillValue()

uint32 Unit::GetWeaponSkillValue	(	WeaponAttackType	attType,
		Unit const *	target = `nullptr`
	)		const

Definition at line 3731 of file Unit.cpp.

{
    uint32 value = 0;
    if (Player const* player = ToPlayer())
    {
        Item* item = player->GetWeaponForAttack(attType, true);
 
        // feral or unarmed skill only for base attack
        if (attType != BASE_ATTACK && !item)
            return 0;
 
        if (IsInFeralForm())
            return GetMaxSkillValueForLevel();              // always maximized SKILL_FERAL_COMBAT in fact
 
        // weapon skill or (unarmed for base attack)
        uint32 skill = SKILL_UNARMED;
        if (item)
            skill = item->GetSkill();
 
        // in PvP use full skill instead current skill value
        value = (target && target->IsControlledByPlayer())
                ? player->GetMaxSkillValue(skill)
                : player->GetSkillValue(skill);
        // Modify value from ratings
        value += uint32(player->GetRatingBonusValue(CR_WEAPON_SKILL));
        switch (attType)
        {
            case BASE_ATTACK:
                value += uint32(player->GetRatingBonusValue(CR_WEAPON_SKILL_MAINHAND));
                break;
            case OFF_ATTACK:
                value += uint32(player->GetRatingBonusValue(CR_WEAPON_SKILL_OFFHAND));
                break;
            case RANGED_ATTACK:
                value += uint32(player->GetRatingBonusValue(CR_WEAPON_SKILL_RANGED));
                break;
            default:
                break;
        }
    }
    else
        value = GetUnitMeleeSkill(target);
    return value;
}

◆ HandleAuraProc()

bool Unit::HandleAuraProc	(	Unit *	victim,
		uint32	damage,
		Aura *	triggeredByAura,
		SpellInfo const *	procSpell,
		uint32	procFlag,
		uint32	procEx,
		uint32	cooldown,
		bool *	handled
	)

private

Definition at line 8678 of file Unit.cpp.

{
    SpellInfo const* dummySpell = triggeredByAura->GetSpellInfo();
 
    switch (dummySpell->SpellFamilyName)
    {
        case SPELLFAMILY_GENERIC:
            switch (dummySpell->Id)
            {
                // Nevermelting Ice Crystal
                case 71564:
                    RemoveAuraFromStack(71564);
                    *handled = true;
                    break;
                // Gaseous Bloat
                case 70672:
                case 72455:
                case 72832:
                case 72833:
                    {
                        if (Unit* caster = triggeredByAura->GetCaster())
                            if (victim && caster->GetGUID() == victim->GetGUID())
                            {
                                *handled = true;
                                uint32 stack = triggeredByAura->GetStackAmount();
                                int32 const mod = (GetMap()->GetSpawnMode() & 1) ? 1500 : 1250;
                                int32 dmg = 0;
                                for (uint8 i = 1; i <= stack; ++i)
                                    dmg += mod * i;
                                caster->CastCustomSpell(70701, SPELLVALUE_BASE_POINT0, dmg);
                            }
                        break;
                    }
                // Ball of Flames Proc
                case 71756:
                case 72782:
                case 72783:
                case 72784:
                    RemoveAuraFromStack(dummySpell->Id);
                    *handled = true;
                    break;
                // Discerning Eye of the Beast
                case 59915:
                    {
                        CastSpell(this, 59914, true);   // 59914 already has correct basepoints in DBC, no need for custom bp
                        *handled = true;
                        break;
                    }
                // Swift Hand of Justice
                case 59906:
                    {
                        int32 bp0 = CalculatePct(GetMaxHealth(), dummySpell->Effects[EFFECT_0]. CalcValue());
                        CastCustomSpell(this, 59913, &bp0, nullptr, nullptr, true);
                        *handled = true;
                        break;
                    }
            }
 
            break;
        case SPELLFAMILY_MAGE:
            {
                // Combustion
                switch (dummySpell->Id)
                {
                    case 11129:
                        {
                            *handled = true;
                            Unit* caster = triggeredByAura->GetCaster();
                            if (!caster || !damage)
                                return false;
 
                            // last charge and crit
                            if (triggeredByAura->GetCharges() <= 1 && (procEx & PROC_EX_CRITICAL_HIT))
                                return true;                        // charge counting (will removed)
 
                            CastSpell(this, 28682, true);
 
                            return procEx & PROC_EX_CRITICAL_HIT;
                        }
                    // Empowered Fire
                    case 31656:
                    case 31657:
                    case 31658:
                        {
                            *handled = true;
 
                            SpellInfo const* spInfo = sSpellMgr->GetSpellInfo(67545);
                            if (!spInfo)
                                return false;
 
                            int32 bp0 = int32(CalculatePct(GetMaxPower(POWER_MANA), spInfo->Effects[0].CalcValue()));
                            CastCustomSpell(this, 67545, &bp0, nullptr, nullptr, true, nullptr, triggeredByAura->GetEffect(EFFECT_0), GetGUID());
                            return true;
                        }
                }
                break;
            }
        case SPELLFAMILY_DEATHKNIGHT:
            {
                // Blood of the North
                // Reaping
                // Death Rune Mastery
                // xinef: Icon 22 is used for item bonus, skip
                if (dummySpell->SpellIconID == 3041 || (dummySpell->SpellIconID == 22 && dummySpell->Id != 62459) || dummySpell->SpellIconID == 2622)
                {
                    *handled = true;
                    // Convert recently used Blood Rune to Death Rune
                    if (Player* player = ToPlayer())
                    {
                        if (player->getClass() != CLASS_DEATH_KNIGHT)
                            return false;
 
                        // xinef: not true
                        //RuneType rune = ToPlayer()->GetLastUsedRune();
                        // can't proc from death rune use
                        //if (rune == RUNE_DEATH)
                        //    return false;
                        AuraEffect* aurEff = triggeredByAura->GetEffect(EFFECT_0);
                        if (!aurEff)
                            return false;
 
                        // Reset amplitude - set death rune remove timer to 30s
                        aurEff->ResetPeriodic(true);
                        uint32 runesLeft;
 
                        if (dummySpell->SpellIconID == 2622)
                            runesLeft = 2;
                        else
                            runesLeft = 1;
 
                        for (uint8 i = 0; i < MAX_RUNES && runesLeft; ++i)
                        {
                            if (dummySpell->SpellIconID == 2622)
                            {
                                if (player->GetCurrentRune(i) == RUNE_DEATH ||
                                        player->GetBaseRune(i) == RUNE_BLOOD)
                                    continue;
                            }
                            else
                            {
                                if (player->GetCurrentRune(i) == RUNE_DEATH ||
                                        player->GetBaseRune(i) != RUNE_BLOOD)
                                    continue;
                            }
                            if (player->GetRuneCooldown(i) != player->GetRuneBaseCooldown(i, false))
                                continue;
 
                            --runesLeft;
                            // Mark aura as used
                            player->AddRuneByAuraEffect(i, RUNE_DEATH, aurEff);
                        }
                        return true;
                    }
                    return false;
                }
                break;
            }
        case SPELLFAMILY_WARRIOR:
            {
                switch (dummySpell->Id)
                {
                    // Item - Warrior T10 Protection 4P Bonus
                    case 70844:
                        {
                            int32 basepoints0 = CalculatePct(GetMaxHealth(), dummySpell->Effects[EFFECT_1]. CalcValue());
                            CastCustomSpell(this, 70845, &basepoints0, nullptr, nullptr, true);
                            break;
                        }
                    default:
                        break;
                }
                break;
            }
        case SPELLFAMILY_SHAMAN:
        {
            // Flurry
            if ((dummySpell->SpellFamilyFlags[1] & 0x00000200) != 0)
            {
                if (cooldown)
                {
                    if (HasSpellCooldown(dummySpell->Id))
                    {
                        *handled = true;
                        break;
                    }
 
                    AddSpellCooldown(dummySpell->Id, 0, cooldown);
                }
            }
            break;
        }
    }
    return false;
}

◆ HandleAuraRaidProcFromCharge()

bool Unit::HandleAuraRaidProcFromCharge ( AuraEffect * triggeredByAura )

private

Definition at line 17701 of file Unit.cpp.

{
    // aura can be deleted at casts
    SpellInfo const* spellProto = triggeredByAura->GetSpellInfo();
 
    uint32 damageSpellId;
    switch (spellProto->Id)
    {
        case 57949:            // shiver
            damageSpellId = 57952;
            //animationSpellId = 57951; dummy effects for jump spell have unknown use (see also 41637)
            break;
        case 59978:            // shiver
            damageSpellId = 59979;
            break;
        case 43593:            // Cold Stare
            damageSpellId = 43594;
            break;
        default:
            LOG_ERROR("entities.unit", "Unit::HandleAuraRaidProcFromCharge, received unhandled spell: {}", spellProto->Id);
            return false;
    }
 
    ObjectGuid caster_guid = triggeredByAura->GetCasterGUID();
 
    // jumps
    int32 jumps = triggeredByAura->GetBase()->GetCharges() - 1;
 
    // current aura expire
    triggeredByAura->GetBase()->SetCharges(1);             // will removed at next charges decrease
 
    // next target selection
    if (jumps > 0)
    {
        if (Unit* caster = triggeredByAura->GetCaster())
        {
            float radius = triggeredByAura->GetSpellInfo()->Effects[triggeredByAura->GetEffIndex()].CalcRadius(caster);
            if (Unit* target = GetNextRandomRaidMemberOrPet(radius))
            {
                CastSpell(target, spellProto, true, nullptr, triggeredByAura, caster_guid);
                if (Aura* aura = target->GetAura(spellProto->Id, caster->GetGUID()))
                    aura->SetCharges(jumps);
            }
        }
    }
 
    CastSpell(this, damageSpellId, true, nullptr, triggeredByAura, caster_guid);
 
    return true;
}

◆ HandleAuraRaidProcFromChargeWithValue()

bool Unit::HandleAuraRaidProcFromChargeWithValue ( AuraEffect * triggeredByAura )

private

Definition at line 17612 of file Unit.cpp.

{
    // aura can be deleted at casts
    SpellInfo const* spellProto = triggeredByAura->GetSpellInfo();
    int32 heal = triggeredByAura->GetAmount();
    ObjectGuid caster_guid = triggeredByAura->GetCasterGUID();
 
    // Currently only Prayer of Mending
    if (!(spellProto->SpellFamilyName == SPELLFAMILY_PRIEST && spellProto->SpellFamilyFlags[1] & 0x20))
    {
        LOG_DEBUG("spells.aura", "Unit::HandleAuraRaidProcFromChargeWithValue, received not handled spell: {}", spellProto->Id);
        return false;
    }
 
    // jumps
    int32 jumps = triggeredByAura->GetBase()->GetCharges() - 1;
 
    // current aura expire
    triggeredByAura->GetBase()->SetCharges(1);             // will removed at next charges decrease
 
    // next target selection
    if (jumps > 0)
    {
        if (Unit* caster = triggeredByAura->GetCaster())
        {
            // smart healing
            float radius = triggeredByAura->GetSpellInfo()->Effects[triggeredByAura->GetEffIndex()].CalcRadius(caster);
            std::list<Unit*> nearMembers;
 
            Player* player = nullptr;
            if (GetTypeId() == TYPEID_PLAYER)
                player = ToPlayer();
            else if (GetOwner())
                player = GetOwner()->ToPlayer();
 
            if (player)
            {
                Group* group = player->GetGroup();
                if (!group)
                {
                    if (player != this)
                    {
                        if (IsWithinDistInMap(player, radius))
                            nearMembers.push_back(player);
                    }
                    else if (Unit* pet = GetGuardianPet())
                    {
                        if (IsWithinDistInMap(pet, radius))
                            nearMembers.push_back(pet);
                    }
                }
                else
                {
                    for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
                        if (Player* Target = itr->GetSource())
                        {
                            if (Target != this && !IsWithinDistInMap(Target, radius))
                                continue;
 
                            // IsHostileTo check duel and controlled by enemy
                            if (Target != this && Target->IsAlive() && !IsHostileTo(Target))
                                nearMembers.push_back(Target);
 
                            // Push player's pet to vector
                            if (Unit* pet = Target->GetGuardianPet())
                                if (pet != this && pet->IsAlive() && IsWithinDistInMap(pet, radius) && !IsHostileTo(pet))
                                    nearMembers.push_back(pet);
                        }
                }
 
                if (!nearMembers.empty())
                {
                    nearMembers.sort(Acore::HealthPctOrderPred());
                    if (Unit* target = nearMembers.front())
                    {
                        CastSpell(target, 41637 /*Dummy visual effect triggered by main spell cast*/, true);
                        CastCustomSpell(target, spellProto->Id, &heal, nullptr, nullptr, true, nullptr, triggeredByAura, caster_guid);
                        if (Aura* aura = target->GetAura(spellProto->Id, caster->GetGUID()))
                            aura->SetCharges(jumps);
                    }
                }
            }
        }
    }
 
    // heal
    CastCustomSpell(this, 33110, &heal, nullptr, nullptr, true, nullptr, nullptr, caster_guid);
    return true;
}

◆ HandleDummyAuraProc()

bool Unit::HandleDummyAuraProc	(	Unit *	victim,
		uint32	damage,
		AuraEffect *	triggeredByAura,
		SpellInfo const *	procSpell,
		uint32	procFlag,
		uint32	procEx,
		uint32	cooldown,
		Spell const *	spellProc = `nullptr`
	)

private

Definition at line 6489 of file Unit.cpp.

{
    SpellInfo const* dummySpell = triggeredByAura->GetSpellInfo();
    uint32 effIndex = triggeredByAura->GetEffIndex();
    int32  triggerAmount = triggeredByAura->GetAmount();
 
    Item* castItem = triggeredByAura->GetBase()->GetCastItemGUID() && GetTypeId() == TYPEID_PLAYER
                     ? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : nullptr;
 
    uint32 triggered_spell_id = 0;
    uint32 cooldown_spell_id = 0; // for random trigger, will be one of the triggered spell to avoid repeatable triggers
    // otherwise, it's the triggered_spell_id by default
    Unit* target = victim;
    int32 basepoints0 = 0;
    ObjectGuid originalCaster;
 
    switch (dummySpell->SpellFamilyName)
    {
        case SPELLFAMILY_GENERIC:
            {
                switch (dummySpell->Id)
                {
                    // Overkill
                    case 58426:
                        {
                            triggered_spell_id = 58427;
                            break;
                        }
                    // Unstable Power
                    case 24658:
                        {
                            if (!procSpell || procSpell->Id == 24659)
                                return false;
                            // Need remove one 24659 aura
                            RemoveAuraFromStack(24659);
                            return true;
                        }
                    // Restless Strength
                    case 24661:
                        {
                            // Need remove one 24662 aura
                            RemoveAuraFromStack(24662);
                            return true;
                        }
                    // Mark of Malice
                    case 33493:
                        {
                            if (triggeredByAura->GetBase()->GetCharges() > 1)
                                return true;
 
                            target = this;
                            triggered_spell_id = 33494;
                            break;
                        }
                    // Twisted Reflection (boss spell)
                    case 21063:
                        triggered_spell_id = 21064;
                        break;
                    // Vampiric Aura (boss spell)
                    case 38196:
                        {
                            basepoints0 = 3 * damage;               // 300%
                            if (basepoints0 < 0)
                                return false;
 
                            triggered_spell_id = 31285;
                            target = this;
                            break;
                        }
                    // Aura of Madness (Darkmoon Card: Madness trinket)
                    //=====================================================
                    // 39511 Sociopath: +35 strength (Paladin, Rogue, Druid, Warrior)
                    // 40997 Delusional: +70 attack power (Rogue, Hunter, Paladin, Warrior, Druid)
                    // 40998 Kleptomania: +35 agility (Warrior, Rogue, Paladin, Hunter, Druid)
                    // 40999 Megalomania: +41 damage/healing (Druid, Shaman, Priest, Warlock, Mage, Paladin)
                    // 41002 Paranoia: +35 spell/melee/ranged crit strike rating (All classes)
                    // 41005 Manic: +35 haste (spell, melee and ranged) (All classes)
                    // 41009 Narcissism: +35 intellect (Druid, Shaman, Priest, Warlock, Mage, Paladin, Hunter)
                    // 41011 Martyr Complex: +35 stamina (All classes)
                    // 41406 Dementia: Every 5 seconds either gives you +5% damage/healing. (Druid, Shaman, Priest, Warlock, Mage, Paladin)
                    // 41409 Dementia: Every 5 seconds either gives you -5% damage/healing. (Druid, Shaman, Priest, Warlock, Mage, Paladin)
                    case 39446:
                        {
                            if (GetTypeId() != TYPEID_PLAYER || !IsAlive())
                                return false;
 
                            // Select class defined buff
                            switch (getClass())
                            {
                                case CLASS_PALADIN:                 // 39511, 40997, 40998, 40999, 41002, 41005, 41009, 41011, 41409
                                case CLASS_DRUID:                   // 39511, 40997, 40998, 40999, 41002, 41005, 41009, 41011, 41409
                                    triggered_spell_id = RAND(39511, 40997, 40998, 40999, 41002, 41005, 41009, 41011, 41409);
                                    cooldown_spell_id = 39511;
                                    break;
                                case CLASS_ROGUE:                   // 39511, 40997, 40998, 41002, 41005, 41011
                                case CLASS_WARRIOR:                 // 39511, 40997, 40998, 41002, 41005, 41011
                                case CLASS_DEATH_KNIGHT:
                                    triggered_spell_id = RAND(39511, 40997, 40998, 41002, 41005, 41011);
                                    cooldown_spell_id = 39511;
                                    break;
                                case CLASS_PRIEST:                  // 40999, 41002, 41005, 41009, 41011, 41406, 41409
                                case CLASS_SHAMAN:                  // 40999, 41002, 41005, 41009, 41011, 41406, 41409
                                case CLASS_MAGE:                    // 40999, 41002, 41005, 41009, 41011, 41406, 41409
                                case CLASS_WARLOCK:                 // 40999, 41002, 41005, 41009, 41011, 41406, 41409
                                    triggered_spell_id = RAND(40999, 41002, 41005, 41009, 41011, 41406, 41409);
                                    cooldown_spell_id = 40999;
                                    break;
                                case CLASS_HUNTER:                  // 40997, 40999, 41002, 41005, 41009, 41011, 41406, 41409
                                    triggered_spell_id = RAND(40997, 40999, 41002, 41005, 41009, 41011, 41406, 41409);
                                    cooldown_spell_id = 40997;
                                    break;
                                default:
                                    return false;
                            }
 
                            target = this;
                            if (roll_chance_i(10))
                                ToPlayer()->Say("This is Madness!", LANG_UNIVERSAL); // TODO: It should be moved to database, shouldn't it?
                            break;
                        }
                    // Sunwell Exalted Caster Neck (??? neck)
                    // cast ??? Light's Wrath if Exalted by Aldor
                    // cast ??? Arcane Bolt if Exalted by Scryers
                    case 46569:
                        return false;                           // old unused version
                    // Sunwell Exalted Caster Neck (Shattered Sun Pendant of Acumen neck)
                    // cast 45479 Light's Wrath if Exalted by Aldor
                    // cast 45429 Arcane Bolt if Exalted by Scryers
                    case 45481:
                        {
                            Player* player = ToPlayer();
                            if (!player)
                                return false;
 
                            // Get Aldor reputation rank
                            if (player->GetReputationRank(932) == REP_EXALTED)
                            {
                                target = this;
                                triggered_spell_id = 45479;
                                break;
                            }
                            // Get Scryers reputation rank
                            if (player->GetReputationRank(934) == REP_EXALTED)
                            {
                                // triggered at positive/self casts also, current attack target used then
                                if (target && IsFriendlyTo(target))
                                {
                                    target = GetVictim();
                                    if (!target)
                                    {
                                        target = player->GetSelectedUnit();
                                        if (!target)
                                            return false;
                                    }
                                    if (IsFriendlyTo(target))
                                        return false;
                                }
 
                                triggered_spell_id = 45429;
                                break;
                            }
                            return false;
                        }
                    // Sunwell Exalted Melee Neck (Shattered Sun Pendant of Might neck)
                    // cast 45480 Light's Strength if Exalted by Aldor
                    // cast 45428 Arcane Strike if Exalted by Scryers
                    case 45482:
                        {
                            if (GetTypeId() != TYPEID_PLAYER)
                                return false;
 
                            // Get Aldor reputation rank
                            if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
                            {
                                target = this;
                                triggered_spell_id = 45480;
                                break;
                            }
                            // Get Scryers reputation rank
                            if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
                            {
                                triggered_spell_id = 45428;
                                break;
                            }
                            return false;
                        }
                    // Sunwell Exalted Tank Neck (Shattered Sun Pendant of Resolve neck)
                    // cast 45431 Arcane Insight if Exalted by Aldor
                    // cast 45432 Light's Ward if Exalted by Scryers
                    case 45483:
                        {
                            if (GetTypeId() != TYPEID_PLAYER)
                                return false;
 
                            // Get Aldor reputation rank
                            if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
                            {
                                target = this;
                                triggered_spell_id = 45432;
                                break;
                            }
                            // Get Scryers reputation rank
                            if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
                            {
                                target = this;
                                triggered_spell_id = 45431;
                                break;
                            }
                            return false;
                        }
                    // Sunwell Exalted Healer Neck (Shattered Sun Pendant of Restoration neck)
                    // cast 45478 Light's Salvation if Exalted by Aldor
                    // cast 45430 Arcane Surge if Exalted by Scryers
                    case 45484:
                        {
                            if (GetTypeId() != TYPEID_PLAYER)
                                return false;
 
                            // Get Aldor reputation rank
                            if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
                            {
                                target = this;
                                triggered_spell_id = 45478;
                                break;
                            }
                            // Get Scryers reputation rank
                            if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
                            {
                                triggered_spell_id = 45430;
                                break;
                            }
                            return false;
                        }
                    // Kill command
                    case 58914:
                        {
                            // Remove aura stack from pet
                            RemoveAuraFromStack(58914);
                            Unit* owner = GetOwner();
                            if (!owner)
                                return true;
                            // reduce the owner's aura stack
                            owner->RemoveAuraFromStack(34027);
                            return true;
                        }
                    // Vampiric Touch (generic, used by some boss)
                    case 52723:
                    case 60501:
                        {
                            triggered_spell_id = 52724;
                            basepoints0 = damage / 2;
                            target = this;
                            break;
                        }
                    // Divine purpose
                    case 31871:
                    case 31872:
                        {
                            // Roll chane
                            if (!victim || !victim->IsAlive() || !roll_chance_i(triggerAmount))
                                return false;
 
                            // Remove any stun effect on target
                            victim->RemoveAurasWithMechanic(1 << MECHANIC_STUN, AURA_REMOVE_BY_ENEMY_SPELL);
                            return true;
                        }
                    // Glyph of Life Tap
                    case 63320:
                        {
                            triggered_spell_id = 63321; // Life Tap
                            break;
                        }
                    case 71519: // Deathbringer's Will Normal
                        {
                            if (GetTypeId() != TYPEID_PLAYER || HasSpellCooldown(71484))
                                return false;
 
                            AddSpellCooldown(71484, 0, cooldown);
 
                            std::vector<uint32> RandomSpells;
                            switch (getClass())
                            {
                                case CLASS_WARRIOR:
                                case CLASS_PALADIN:
                                case CLASS_DEATH_KNIGHT:
                                    RandomSpells.push_back(71484);
                                    RandomSpells.push_back(71491);
                                    RandomSpells.push_back(71492);
                                    break;
                                case CLASS_SHAMAN:
                                case CLASS_ROGUE:
                                    RandomSpells.push_back(71486);
                                    RandomSpells.push_back(71485);
                                    RandomSpells.push_back(71492);
                                    break;
                                case CLASS_DRUID:
                                    RandomSpells.push_back(71484);
                                    RandomSpells.push_back(71485);
                                    RandomSpells.push_back(71492);
                                    break;
                                case CLASS_HUNTER:
                                    RandomSpells.push_back(71486);
                                    RandomSpells.push_back(71491);
                                    RandomSpells.push_back(71485);
                                    break;
                                default:
                                    return false;
                            }
                            if (RandomSpells.empty()) // shouldn't happen
                                return false;
 
                            uint8 rand_spell = irand(0, (RandomSpells.size() - 1));
                            CastSpell(target, RandomSpells[rand_spell], true, castItem, triggeredByAura, originalCaster);
                            break;
                        }
                    case 71562: // Deathbringer's Will Heroic
                        {
                            if (GetTypeId() != TYPEID_PLAYER || HasSpellCooldown(71561))
                                return false;
 
                            AddSpellCooldown(71561, 0, cooldown);
 
                            std::vector<uint32> RandomSpells;
                            switch (getClass())
                            {
                                case CLASS_WARRIOR:
                                case CLASS_PALADIN:
                                case CLASS_DEATH_KNIGHT:
                                    RandomSpells.push_back(71561);
                                    RandomSpells.push_back(71559);
                                    RandomSpells.push_back(71560);
                                    break;
                                case CLASS_SHAMAN:
                                case CLASS_ROGUE:
                                    RandomSpells.push_back(71558);
                                    RandomSpells.push_back(71556);
                                    RandomSpells.push_back(71560);
                                    break;
                                case CLASS_DRUID:
                                    RandomSpells.push_back(71561);
                                    RandomSpells.push_back(71556);
                                    RandomSpells.push_back(71560);
                                    break;
                                case CLASS_HUNTER:
                                    RandomSpells.push_back(71558);
                                    RandomSpells.push_back(71559);
                                    RandomSpells.push_back(71556);
                                    break;
                                default:
                                    return false;
                            }
                            if (RandomSpells.empty()) // shouldn't happen
                                return false;
 
                            uint8 rand_spell = irand(0, (RandomSpells.size() - 1));
                            CastSpell(target, RandomSpells[rand_spell], true, castItem, triggeredByAura, originalCaster);
                            break;
                        }
                    // Freya, Petrified Bark
                    case 62933:
                    case 62337:
                        {
                            if (!victim)
                                return false;
 
                            int32 dmg = damage;
                            victim->CastCustomSpell(this, 62379, &dmg, 0, 0, true);
                            return true;
                        }
                    // Trial of the Champion, Earth Shield
                    case 67534:
                        {
                            const int32 dmg = (int32)damage;
                            CastCustomSpell(this, 67535, &dmg, nullptr, nullptr, true, 0, triggeredByAura, triggeredByAura->GetCasterGUID());
                            return true;
                        }
                    // Trial of the Crusader, Faction Champions, Retaliation
                    case 65932:
                        {
                            // check attack comes not from behind
                            if (!victim || !HasInArc(M_PI, victim))
                                return false;
 
                            triggered_spell_id = 65934;
                            break;
                        }
                    // Pit of Saron, Tyrannus, Overlord's Brand
                    case 69172: // everything except for DoTs
                        {
                            if (!target)
                                return false;
                            if (Unit* caster = triggeredByAura->GetCaster())
                            {
                                if (procFlag & (PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS | PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS))
                                {
                                    int32 dmg = 5.5f * damage;
                                    target->CastCustomSpell(caster, 69190, &dmg, 0, 0, true);
                                }
                                else
                                {
                                    if (caster->GetVictim())
                                    {
                                        int32 dmg = damage;
                                        target->CastCustomSpell(caster->GetVictim(), 69189, &dmg, 0, 0, true);
                                    }
                                }
                            }
                            return true;
                        }
                    // Pit of Saron, Tyrannus, Overlord's Brand
                    case 69173: // only DoTs
                        {
                            if (!target)
                                return false;
                            if (Unit* caster = triggeredByAura->GetCaster())
                            {
                                if (procEx & PROC_EX_INTERNAL_HOT)
                                {
                                    int32 dmg = 5.5f * damage;
                                    target->CastCustomSpell(caster, 69190, &dmg, 0, 0, true);
                                }
                                else
                                {
                                    if (caster->GetVictim())
                                    {
                                        int32 dmg = damage;
                                        target->CastCustomSpell(caster->GetVictim(), 69189, &dmg, 0, 0, true);
                                    }
                                }
                            }
                            return true;
                        }
                    // Icecrown Citadel, Lady Deathwhisper, Vampiric Might
                    case 70674:
                        {
                            if (Unit* caster = triggeredByAura->GetCaster())
                            {
                                int32 dmg = 3 * damage;
                                caster->CastCustomSpell(caster, 70677, &dmg, 0, 0, true);
                            }
                            return true;
                        }
                    // Item: Purified Shard of the Gods
                    case 69755:
                        {
                            triggered_spell_id = ((procFlag & PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS) ? 69733 : 69729);
                            break;
                        }
                    // Item: Shiny Shard of the Gods
                    case 69739:
                        {
                            triggered_spell_id = ((procFlag & PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS) ? 69734 : 69730);
                            break;
                        }
                    // VoA: Meteor Fists koralon
                    case 66725:
                    case 68161:
                        {
                            triggered_spell_id = 66765; // handled by spell_difficulty
                            break;
                        }
                }
                break;
            }
        case SPELLFAMILY_MAGE:
            {
                // Magic Absorption
                if (dummySpell->SpellIconID == 459)             // only this spell has SpellIconID == 459 and dummy aura
                {
                    if (getPowerType() != POWER_MANA)
                        return false;
 
                    // mana reward
                    basepoints0 = CalculatePct(int32(GetMaxPower(POWER_MANA)), triggerAmount);
                    target = this;
                    triggered_spell_id = 29442;
                    break;
                }
                // Hot Streak
                if (dummySpell->SpellIconID == 2999)
                {
                    if (effIndex != 0)
                        return false;
                    AuraEffect* counter = triggeredByAura->GetBase()->GetEffect(EFFECT_1);
                    if (!counter)
                        return true;
 
                    // Count spell criticals in a row in second aura
                    if (procEx & PROC_EX_CRITICAL_HIT)
                    {
                        counter->SetAmount(counter->GetAmount() * 2);
                        if (counter->GetAmount() < 100) // not enough
                            return true;
                        // Crititcal counted -> roll chance
                        if (roll_chance_i(triggerAmount))
                            CastSpell(this, 48108, true, castItem, triggeredByAura);
                    }
                    counter->SetAmount(25);
                    return true;
                }
                // Incanter's Regalia set (add trigger chance to Mana Shield)
                if (dummySpell->SpellFamilyFlags[0] & 0x8000)
                {
                    if (GetTypeId() != TYPEID_PLAYER)
                        return false;
 
                    target = this;
                    triggered_spell_id = 37436;
                    break;
                }
                switch (dummySpell->Id)
                {
                    // Glyph of Polymorph
                    case 56375:
                        {
                            if (!target)
                                return false;
                            target->RemoveAurasByType(SPELL_AURA_PERIODIC_DAMAGE, ObjectGuid::Empty, target->GetAura(32409)); // SW:D shall not be removed.
                            target->RemoveAurasByType(SPELL_AURA_PERIODIC_DAMAGE_PERCENT);
                            target->RemoveAurasByType(SPELL_AURA_PERIODIC_LEECH);
                            return true;
                        }
                    // Glyph of Icy Veins
                    case 56374:
                        {
                            RemoveAurasByType(SPELL_AURA_HASTE_SPELLS, ObjectGuid::Empty, 0, true, false);
                            RemoveAurasByType(SPELL_AURA_MOD_DECREASE_SPEED);
                            return true;
                        }
                    // Glyph of Ice Block
                    case 56372:
                        {
                            Player* player = ToPlayer();
                            if (!player)
                                return false;
 
                            SpellCooldowns const cooldowns = player->GetSpellCooldowns();
                            // remove cooldowns on all ranks of Frost Nova
                            for (SpellCooldowns::const_iterator itr = cooldowns.begin(); itr != cooldowns.end(); ++itr)
                            {
                                SpellInfo const* cdSpell = sSpellMgr->GetSpellInfo(itr->first);
                                // Frost Nova
                                if (cdSpell && cdSpell->SpellFamilyName == SPELLFAMILY_MAGE
                                        && cdSpell->SpellFamilyFlags[0] & 0x00000040)
                                    player->RemoveSpellCooldown(cdSpell->Id, true);
                            }
                            break;
                        }
                }
                break;
            }
        case SPELLFAMILY_WARRIOR:
            {
                switch (dummySpell->Id)
                {
                    // Victorious
                    case 32216:
                        {
                            RemoveAura(dummySpell->Id);
                            return false;
                        }
                }
 
                // Second Wind
                if (dummySpell->SpellIconID == 1697)
                {
                    // only for spells and hit/crit (trigger start always) and not start from self casted spells (5530 Mace Stun Effect for example)
                    if (procSpell == 0 || !(procEx & (PROC_EX_NORMAL_HIT | PROC_EX_CRITICAL_HIT)) || this == victim)
                        return false;
                    // Need stun or root mechanic
                    if (!(procSpell->GetAllEffectsMechanicMask() & ((1 << MECHANIC_ROOT) | (1 << MECHANIC_STUN))))
                        return false;
 
                    switch (dummySpell->Id)
                    {
                        case 29838:
                            triggered_spell_id = 29842;
                            break;
                        case 29834:
                            triggered_spell_id = 29841;
                            break;
                        case 42770:
                            triggered_spell_id = 42771;
                            break;
                        default:
                            LOG_ERROR("entities.unit", "Unit::HandleDummyAuraProc: non handled spell id: {} (SW)", dummySpell->Id);
                            return false;
                    }
 
                    target = this;
                    break;
                }
                break;
            }
        case SPELLFAMILY_WARLOCK:
            {
                // Seed of Corruption
                if (dummySpell->SpellFamilyFlags[1] & 0x00000010)
                {
                    if (procSpell && procSpell->SpellFamilyFlags[1] & 0x8000)
                        return false;
                    // if damage is more than need or target die from damage deal finish spell
                    if (triggeredByAura->GetAmount() <= int32(damage) || GetHealth() <= damage)
                    {
                        // remember guid before aura delete
                        ObjectGuid casterGuid = triggeredByAura->GetCasterGUID();
 
                        // Remove aura (before cast for prevent infinite loop handlers)
                        RemoveAurasDueToSpell(triggeredByAura->GetId());
 
                        uint32 spell = sSpellMgr->GetSpellWithRank(27285, dummySpell->GetRank());
 
                        // Cast finish spell (triggeredByAura already not exist!)
                        if (Unit* caster = ObjectAccessor::GetUnit(*this, casterGuid))
                        {
                            this->CastSpell(this, 37826, true); // VISUAL!
                            caster->CastSpell(this, spell, true, castItem);
                        }
 
                        return true;                            // no hidden cooldown
                    }
 
                    // Damage counting
                    triggeredByAura->SetAmount(triggeredByAura->GetAmount() - damage);
                    return true;
                }
                // Seed of Corruption (Mobs cast) - no die req
                if (dummySpell->SpellFamilyFlags.IsEqual(0, 0, 0) && dummySpell->SpellIconID == 1932)
                {
                    // if damage is more than need deal finish spell
                    if (triggeredByAura->GetAmount() <= int32(damage))
                    {
                        // remember guid before aura delete
                        ObjectGuid casterGuid = triggeredByAura->GetCasterGUID();
 
                        // Remove aura (before cast for prevent infinite loop handlers)
                        RemoveAurasDueToSpell(triggeredByAura->GetId());
 
                        // Cast finish spell (triggeredByAura already not exist!)
                        if (Unit* caster = ObjectAccessor::GetUnit(*this, casterGuid))
                        {
                            this->CastSpell(this, 37826, true); // VISUAL!
                            caster->CastSpell(this, 32865, true, castItem);
                        }
                        return true;                            // no hidden cooldown
                    }
                    // Damage counting
                    triggeredByAura->SetAmount(triggeredByAura->GetAmount() - damage);
                    return true;
                }
                switch (dummySpell->Id)
                {
                    // Nightfall
                    case 18094:
                    case 18095:
                    // Glyph of corruption
                    case 56218:
                        {
                            target = this;
                            triggered_spell_id = 17941;
                            break;
                        }
                    // Soul Leech
                    case 30293:
                    case 30295:
                    case 30296:
                        {
                            // Improved Soul Leech
                            AuraEffectList const& SoulLeechAuras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
                            for (Unit::AuraEffectList::const_iterator i = SoulLeechAuras.begin(); i != SoulLeechAuras.end(); ++i)
                            {
                                if ((*i)->GetId() == 54117 || (*i)->GetId() == 54118)
                                {
                                    if ((*i)->GetEffIndex() != 0)
                                        continue;
                                    basepoints0 = int32((*i)->GetAmount());
                                    target = GetGuardianPet();
                                    if (target)
                                    {
                                        // regen mana for pet
                                        CastCustomSpell(target, 54607, &basepoints0, nullptr, nullptr, true, castItem, triggeredByAura);
                                    }
                                    // regen mana for caster
                                    CastCustomSpell(this, 59117, &basepoints0, nullptr, nullptr, true, castItem, triggeredByAura);
                                    // Get second aura of spell for replenishment effect on party
                                    if (AuraEffect const* aurEff = (*i)->GetBase()->GetEffect(EFFECT_1))
                                    {
                                        // Replenishment - roll chance
                                        if (roll_chance_i(aurEff->GetAmount()))
                                        {
                                            CastSpell(this, 57669, true, castItem, triggeredByAura);
                                        }
                                    }
                                    break;
                                }
                            }
                            // health
                            basepoints0 = CalculatePct(int32(damage), triggerAmount);
                            target = this;
                            triggered_spell_id = 30294;
                            break;
                        }
                    // Shadowflame (Voidheart Raiment set bonus)
                    case 37377:
                        {
                            triggered_spell_id = 37379;
                            break;
                        }
                    // Pet Healing (Corruptor Raiment or Rift Stalker Armor)
                    case 37381:
                        {
                            target = GetGuardianPet();
                            if (!target)
                                return false;
 
                            // heal amount
                            basepoints0 = CalculatePct(int32(damage), triggerAmount);
                            triggered_spell_id = 37382;
                            break;
                        }
                    // Shadowflame Hellfire (Voidheart Raiment set bonus)
                    case 39437:
                        {
                            triggered_spell_id = 37378;
                            break;
                        }
                }
                break;
            }
        case SPELLFAMILY_PRIEST:
            {
                // Body and Soul
                if (dummySpell->SpellIconID == 2218)
                {
                    // Proc only from Abolish desease on self cast
                    if (procSpell->Id != 552 || victim != this || !roll_chance_i(triggerAmount))
                        return false;
                    triggered_spell_id = 64136;
                    target = this;
                    break;
                }
                switch (dummySpell->Id)
                {
                    // Vampiric Embrace
                    case 15286:
                        {
                            if (!victim || !victim->IsAlive() || procSpell->SpellFamilyFlags[1] & 0x80000)
                                return false;
 
                            // heal amount
                            int32 total = CalculatePct(int32(damage), triggerAmount);
                            int32 team = total / 5;
                            int32 self = total - team;
                            CastCustomSpell(this, 15290, &team, &self, nullptr, true, castItem, triggeredByAura);
                            return true;                                // no hidden cooldown
                        }
                    // Priest Tier 6 Trinket (Ashtongue Talisman of Acumen)
                    case 40438:
                        {
                            // Shadow Word: Pain
                            if (procSpell->SpellFamilyFlags[0] & 0x8000)
                                triggered_spell_id = 40441;
                            // Renew
                            else if (procSpell->SpellFamilyFlags[0] & 0x40)
                                triggered_spell_id = 40440;
                            else
                                return false;
 
                            target = this;
                            break;
                        }
                    // Improved Shadowform
                    case 47570:
                    case 47569:
                        {
                            if (!roll_chance_i(triggerAmount))
                                return false;
 
                            RemoveMovementImpairingAuras(true);
                            break;
                        }
                    // Glyph of Dispel Magic
                    case 55677:
                        {
                            // Dispel Magic shares spellfamilyflag with abolish disease
                            if (procSpell->SpellIconID != 74)
                                return false;
                            if (!target || !target->IsFriendlyTo(this))
                                return false;
 
                            basepoints0 = int32(target->CountPctFromMaxHealth(triggerAmount));
                            triggered_spell_id = 56131;
                            break;
                        }
                    // Oracle Healing Bonus ("Garments of the Oracle" set)
                    case 26169:
                        {
                            // heal amount
                            basepoints0 = int32(CalculatePct(damage, 10));
                            target = this;
                            triggered_spell_id = 26170;
                            break;
                        }
                    // Frozen Shadoweave (Shadow's Embrace set) warning! its not only priest set
                    case 39372:
                        {
                            if (!procSpell || (procSpell->GetSchoolMask() & (SPELL_SCHOOL_MASK_FROST | SPELL_SCHOOL_MASK_SHADOW)) == 0)
                                return false;
 
                            // heal amount
                            basepoints0 = CalculatePct(int32(damage), triggerAmount);
                            target = this;
                            triggered_spell_id = 39373;
                            break;
                        }
                    // Greater Heal (Vestments of Faith (Priest Tier 3) - 4 pieces bonus)
                    case 28809:
                        {
                            triggered_spell_id = 28810;
                            break;
                        }
                    // Priest T10 Healer 2P Bonus
                    case 70770:
                        // Flash Heal
                        if (procSpell->SpellFamilyFlags[0] & 0x800)
                        {
                            triggered_spell_id = 70772;
                            SpellInfo const* blessHealing = sSpellMgr->GetSpellInfo(triggered_spell_id);
                            if (!blessHealing || !victim)
                                return false;
                            basepoints0 = int32(CalculatePct(damage, triggerAmount) / (blessHealing->GetMaxDuration() / blessHealing->Effects[0].Amplitude));
                            victim->CastDelayedSpellWithPeriodicAmount(this, triggered_spell_id, SPELL_AURA_PERIODIC_HEAL, basepoints0);
                            return true;
                        }
                        break;
                }
                break;
            }
        case SPELLFAMILY_DRUID:
            {
                switch (dummySpell->Id)
                {
                    // Glyph of Innervate
                    case 54832:
                        {
                            if (procSpell->SpellIconID != 62)
                                return false;
 
                            int32 mana_perc = triggeredByAura->GetSpellInfo()->Effects[triggeredByAura->GetEffIndex()].CalcValue();
                            basepoints0 = int32(CalculatePct(GetCreatePowers(POWER_MANA), mana_perc) / 10);
                            triggered_spell_id = 54833;
                            target = this;
                            break;
                        }
                    // Glyph of Starfire
                    case 54845:
                        {
                            triggered_spell_id = 54846;
                            break;
                        }
                    // Glyph of Shred
                    case 54815:
                        {
                            if (!target)
                                return false;
 
                            // try to find spell Rip on the target
                            if (AuraEffect const* AurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, 0x00800000, 0x0, 0x0, GetGUID()))
                            {
                                // Rip's max duration, note: spells which modifies Rip's duration also counted like Glyph of Rip
                                uint32 CountMin = AurEff->GetBase()->GetMaxDuration();
 
                                // just Rip's max duration without other spells
                                uint32 CountMax = AurEff->GetSpellInfo()->GetMaxDuration();
 
                                // add possible auras' and Glyph of Shred's max duration
                                CountMax += 3 * triggerAmount * IN_MILLISECONDS;      // Glyph of Shred               -> +6 seconds
                                CountMax += HasAura(54818) ? 4 * IN_MILLISECONDS : 0; // Glyph of Rip                 -> +4 seconds
                                CountMax += HasAura(60141) ? 4 * IN_MILLISECONDS : 0; // Rip Duration/Lacerate Damage -> +4 seconds
 
                                // if min < max -> that means caster didn't cast 3 shred yet
                                // so set Rip's duration and max duration
                                if (CountMin < CountMax)
                                {
                                    AurEff->GetBase()->SetDuration(AurEff->GetBase()->GetDuration() + triggerAmount * IN_MILLISECONDS);
                                    AurEff->GetBase()->SetMaxDuration(CountMin + triggerAmount * IN_MILLISECONDS);
                                    return true;
                                }
                            }
                            // if not found Rip
                            return false;
                        }
                    // Glyph of Rake
                    case 54821:
                        {
                            if (procSpell->SpellVisual[0] == 750 && procSpell->Effects[1].ApplyAuraName == 3)
                            {
                                if (target && target->GetTypeId() == TYPEID_UNIT)
                                {
                                    triggered_spell_id = 54820;
                                    break;
                                }
                            }
                            return false;
                        }
                    // Leader of the Pack
                    case 24932:
                        {
                            if (triggerAmount <= 0)
                                return false;
                            basepoints0 = int32(CountPctFromMaxHealth(triggerAmount));
                            target = this;
                            triggered_spell_id = 34299;
                            if (triggeredByAura->GetCasterGUID() != GetGUID())
                                break;
                            int32 basepoints1 = CalculatePct(GetMaxPower(Powers(POWER_MANA)), triggerAmount * 2);
                            // Improved Leader of the Pack
                            // Check cooldown of heal spell cooldown
                            if (GetTypeId() == TYPEID_PLAYER && !ToPlayer()->HasSpellCooldown(34299))
                                CastCustomSpell(this, 68285, &basepoints1, 0, 0, true, 0, triggeredByAura);
                            break;
                        }
                    // Healing Touch (Dreamwalker Raiment set)
                    case 28719:
                        {
                            // mana back
                            basepoints0 = int32(CalculatePct(spellProc->GetPowerCost(), 30));
                            target = this;
                            triggered_spell_id = 28742;
                            break;
                        }
                    // Glyph of Rejuvenation
                    case 54754:
                        {
                            if (!victim || !victim->HealthBelowPct(uint32(triggerAmount)))
                                return false;
                            basepoints0 = CalculatePct(int32(damage), triggerAmount);
                            triggered_spell_id = 54755;
                            break;
                        }
                    // Healing Touch Refund (Idol of Longevity trinket)
                    case 28847:
                        {
                            target = this;
                            triggered_spell_id = 28848;
                            break;
                        }
                    // Mana Restore (Malorne Raiment set / Malorne Regalia set)
                    case 37288:
                    case 37295:
                        {
                            target = this;
                            triggered_spell_id = 37238;
                            break;
                        }
                    // Druid Tier 6 Trinket
                    case 40442:
                        {
                            float  chance;
 
                            // Starfire
                            if (procSpell->SpellFamilyFlags[0] & 0x4)
                            {
                                triggered_spell_id = 40445;
                                chance = 25.0f;
                            }
                            // Rejuvenation
                            else if (procSpell->SpellFamilyFlags[0] & 0x10)
                            {
                                triggered_spell_id = 40446;
                                chance = 25.0f;
                            }
                            // Mangle (Bear) and Mangle (Cat)
                            else if (procSpell->SpellFamilyFlags[1] & 0x00000440)
                            {
                                triggered_spell_id = 40452;
                                chance = 40.0f;
                            }
                            else
                                return false;
 
                            if (!roll_chance_f(chance))
                                return false;
 
                            target = this;
                            break;
                        }
                    // Maim Interrupt
                    case 44835:
                        {
                            // Deadly Interrupt Effect
                            triggered_spell_id = 32747;
                            break;
                        }
                    // Item - Druid T10 Restoration 4P Bonus (Rejuvenation)
                    case 70664:
                        {
                            // xinef: proc only from normal Rejuvenation, and proc rejuvenation
                            if (!victim || !procSpell || procSpell->SpellIconID != 64)
                                return false;
 
                            Player* caster = ToPlayer();
                            if (!caster)
                                return false;
                            if (!caster->GetGroup() && victim == this)
                                return false;
 
                            CastCustomSpell(70691, SPELLVALUE_BASE_POINT0, damage, victim, true);
                            return true;
                        }
                }
                // Eclipse
                if (dummySpell->SpellIconID == 2856 && GetTypeId() == TYPEID_PLAYER)
                {
                    if (!procSpell || effIndex != 0)
                        return false;
 
                    bool isWrathSpell = (procSpell->SpellFamilyFlags[0] & 1);
 
                    if (!roll_chance_f(dummySpell->ProcChance * (isWrathSpell ? 0.6f : 1.0f)))
                        return false;
 
                    target = this;
                    if (target->HasAura(isWrathSpell ? 48517 : 48518))
                        return false;
 
                    triggered_spell_id = isWrathSpell ? 48518 : 48517;
                    break;
                }
                [[fallthrough]]; // TODO: Not sure whether the fallthrough was a mistake (forgetting a break) or intended. This should be double-checked.
            }
        case SPELLFAMILY_ROGUE:
            {
                switch(dummySpell->Id)
                {
                    // Glyph of Backstab
                    case 56800:
                        {
                            if (victim)
                                if (AuraEffect* aurEff = victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, 0x100000, 0, 0, GetGUID()))
                                    if (Aura* aur = aurEff->GetBase())
                                        if (!aur->IsRemoved() && aur->GetDuration() > 0)
                                            if ((aur->GetApplyTime() + aur->GetMaxDuration() / 1000 + 5) > (GameTime::GetGameTime().count() + aur->GetDuration() / 1000) )
                                            {
                                                aur->SetDuration(aur->GetDuration() + 2000);
                                                return true;
                                            }
                            return false;
                        }
                    // Deadly Throw Interrupt
                    case 32748:
                        {
                            // Prevent cast Deadly Throw Interrupt on self from last effect (apply dummy) of Deadly Throw
                            if (this == victim)
                                return false;
 
                            triggered_spell_id = 32747;
                            break;
                        }
                }
                // Master of subtlety
                if( dummySpell->SpellIconID == 2114 )
                {
                    triggered_spell_id = 31665;
                    basepoints0 = triggerAmount;
                    break;
                }
                // Cut to the Chase
                if (dummySpell->SpellIconID == 2909)
                {
                    // "refresh your Slice and Dice duration to its 5 combo point maximum"
                    // lookup Slice and Dice
                    if (AuraEffect const* aur = GetAuraEffect(SPELL_AURA_MOD_MELEE_HASTE, SPELLFAMILY_ROGUE, 0x40000, 0, 0))
                    {
                        aur->GetBase()->SetDuration(aur->GetSpellInfo()->GetMaxDuration(), true);
                        return true;
                    }
                    return false;
                }
                // Deadly Brew
                else if (dummySpell->SpellIconID == 2963)
                {
                    triggered_spell_id = 3409;
                    break;
                }
                // Quick Recovery
                else if (dummySpell->SpellIconID == 2116)
                {
                    if (!procSpell)
                        return false;
 
                    // energy cost save
                    basepoints0 = CalculatePct(int32(procSpell->ManaCost), triggerAmount);
                    if (basepoints0 <= 0)
                        return false;
 
                    target = this;
                    triggered_spell_id = 31663;
                    break;
                }
                break;
            }
        case SPELLFAMILY_HUNTER:
            {
                switch (dummySpell->SpellIconID)
                {
                    case 2236: // Thrill of the Hunt
                        {
                            if (!procSpell)
                                return false;
 
                            Spell* spell = ToPlayer()->m_spellModTakingSpell;
 
                            // Disable charge drop because of Lock and Load
                            if (spell)
                                ToPlayer()->SetSpellModTakingSpell(spell, false);
 
                            // Explosive Shot
                            if (procSpell->SpellFamilyFlags[2] & 0x200)
                            {
                                if (!victim)
                                    return false;
                                if (AuraEffect const* pEff = victim->GetAuraEffect(SPELL_AURA_PERIODIC_DUMMY, SPELLFAMILY_HUNTER, 0x0, 0x80000000, 0x0, GetGUID()))
                                    basepoints0 = pEff->GetSpellInfo()->CalcPowerCost(this, SpellSchoolMask(pEff->GetSpellInfo()->SchoolMask)) * 4 / 10 / 3;
                            }
                            else
                                basepoints0 = procSpell->CalcPowerCost(this, SpellSchoolMask(procSpell->SchoolMask)) * 4 / 10;
 
                            if (spell)
                                ToPlayer()->SetSpellModTakingSpell(spell, true);
 
                            if (basepoints0 <= 0)
                                return false;
 
                            target = this;
                            triggered_spell_id = 34720;
                            break;
                        }
                    case 3406: // Hunting Party
                        {
                            triggered_spell_id = 57669;
                            target = this;
                            break;
                        }
                    case 3560: // Rapid Recuperation
                        {
                            // This effect only from Rapid Killing (mana regen)
                            if (!(procSpell->SpellFamilyFlags[1] & 0x01000000))
                                return false;
 
                            target = this;
 
                            switch (dummySpell->Id)
                            {
                                case 53228:                             // Rank 1
                                    triggered_spell_id = 56654;
                                    break;
                                case 53232:                             // Rank 2
                                    triggered_spell_id = 58882;
                                    break;
                            }
                            break;
                        }
                }
 
                switch (dummySpell->Id)
                {
                    case 57870: // Glyph of Mend Pet
                        {
                            if (!victim)
                                return false;
 
                            victim->CastSpell(victim, 57894, true, nullptr, nullptr, GetGUID());
                            return true;
                        }
                }
                break;
            }
        case SPELLFAMILY_PALADIN:
            {
                // Light's Beacon - Beacon of Light
                if (dummySpell->Id == 53651)
                {
                    if (!victim)
                        return false;
 
                    // Do not proc from Glyph of Holy Light and Judgement of Light
                    if (procSpell->Id == 20267 || procSpell->Id == 54968)
                    {
                        return false;
                    }
 
                    Unit* beaconTarget = triggeredByAura->GetBase()->GetCaster();
                    if (!beaconTarget || beaconTarget == this || !beaconTarget->GetAura(53563, victim->GetGUID()))
                        return false;
 
                    basepoints0 = int32(damage);
                    triggered_spell_id = procSpell->IsRankOf(sSpellMgr->GetSpellInfo(635)) ? 53652 : 53654;
 
                    victim->CastCustomSpell(beaconTarget, triggered_spell_id, &basepoints0, nullptr, nullptr, true, 0, triggeredByAura, victim->GetGUID());
                    return true;
                }
                // Judgements of the Wise
                if (dummySpell->SpellIconID == 3017)
                {
                    target = this;
                    triggered_spell_id = 31930;
                    // replenishment
                    CastSpell(this, 57669, true, castItem, triggeredByAura);
                    break;
                }
                // Righteous Vengeance
                if (dummySpell->SpellIconID == 3025)
                {
                    if (!victim)
                        return false;
 
                    // 4 damage tick
                    basepoints0 = triggerAmount * damage / 400;
                    triggered_spell_id = 61840;
                    // Add remaining ticks to damage done
                    victim->CastDelayedSpellWithPeriodicAmount(this, triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE, basepoints0);
                    return true;
                }
                // Sheath of Light
                if (dummySpell->SpellIconID == 3030)
                {
                    // 4 healing tick
                    basepoints0 = triggerAmount * damage / 400;
                    triggered_spell_id = 54203;
                    break;
                }
                switch (dummySpell->Id)
                {
                    // Judgement of Light
                    case 20185:
                        {
                            if (!victim || !victim->IsAlive() || victim->HasSpellCooldown(20267))
                                return false;
                            // 2% of base mana
                            basepoints0 = int32(victim->CountPctFromMaxHealth(2));
                            victim->CastCustomSpell(victim, 20267, &basepoints0, 0, 0, true, 0, triggeredByAura);
                            victim->AddSpellCooldown(20267, 0, 4 * IN_MILLISECONDS);
                            return true;
                        }
                    // Judgement of Wisdom
                    case 20186:
                        {
                            if (!victim || !victim->IsAlive() || victim->getPowerType() != POWER_MANA || victim->HasSpellCooldown(20268))
                                return false;
 
                            // 2% of base mana
                            basepoints0 = int32(CalculatePct(victim->GetCreateMana(), 2));
                            victim->CastCustomSpell(victim, 20268, &basepoints0, nullptr, nullptr, true, 0, triggeredByAura);
                            victim->AddSpellCooldown(20268, 0, 4 * IN_MILLISECONDS);
                            return true;
                        }
                    // Holy Power (Redemption Armor set)
                    case 28789:
                        {
                            if (!victim)
                                return false;
 
                            // Set class defined buff
                            switch (victim->getClass())
                            {
                                case CLASS_PALADIN:
                                case CLASS_PRIEST:
                                case CLASS_SHAMAN:
                                case CLASS_DRUID:
                                    triggered_spell_id = 28795;     // Increases the friendly target's mana regeneration by $s1 per 5 sec. for $d.
                                    break;
                                case CLASS_MAGE:
                                case CLASS_WARLOCK:
                                    triggered_spell_id = 28793;     // Increases the friendly target's spell damage and healing by up to $s1 for $d.
                                    break;
                                case CLASS_HUNTER:
                                case CLASS_ROGUE:
                                    triggered_spell_id = 28791;     // Increases the friendly target's attack power by $s1 for $d.
                                    break;
                                case CLASS_WARRIOR:
                                    triggered_spell_id = 28790;     // Increases the friendly target's armor
                                    break;
                                default:
                                    return false;
                            }
                            break;
                        }
                    // Seal of Vengeance (damage calc on apply aura)
                    case 31801:
                        {
                            if (effIndex != 0 || !victim)                       // effect 1, 2 used by seal unleashing code
                                return false;
 
                            // At melee attack or Hammer of the Righteous spell damage considered as melee attack
                            bool stacker = !procSpell || procSpell->Id == 53595;
                            // spells with SPELL_DAMAGE_CLASS_MELEE excluding Judgements
                            bool damager = procSpell && (procSpell->EquippedItemClass != -1 || (procSpell->SpellIconID == 243 && procSpell->SpellVisual[0] == 39));
 
                            if (!stacker && !damager)
                                return false;
 
                            triggered_spell_id = 31803;
 
                            // On target with 5 stacks of Holy Vengeance direct damage is done
                            if (Aura* aur = victim->GetAura(triggered_spell_id, GetGUID()))
                            {
                                if (aur->GetStackAmount() == 5)
                                {
                                    if (stacker)
                                        aur->RefreshDuration();
 
                                    CastSpell(victim, 42463, true, castItem, triggeredByAura);
                                    return true;
                                }
                            }
 
                            if (!stacker)
                                return false;
                            break;
                        }
                    // Seal of Corruption
                    case 53736:
                        {
                            if (effIndex != 0 || !victim)                       // effect 1, 2 used by seal unleashing code
                                return false;
 
                            // At melee attack or Hammer of the Righteous spell damage considered as melee attack
                            bool stacker = !procSpell || procSpell->Id == 53595;
                            // spells with SPELL_DAMAGE_CLASS_MELEE excluding Judgements
                            bool damager = procSpell && (procSpell->EquippedItemClass != -1 || (procSpell->SpellIconID == 243 && procSpell->SpellVisual[0] == 39));
 
                            if (!stacker && !damager)
                                return false;
 
                            triggered_spell_id = 53742;
 
                            // On target with 5 stacks of Blood Corruption direct damage is done
                            if (Aura* aur = victim->GetAura(triggered_spell_id, GetGUID()))
                            {
                                if (aur->GetStackAmount() == 5)
                                {
                                    if (stacker)
                                        aur->RefreshDuration();
 
                                    CastSpell(victim, 53739, true, castItem, triggeredByAura);
                                    return true;
                                }
                            }
 
                            if (!stacker)
                                return false;
                            break;
                        }
                    // Spiritual Attunement
                    case 31785:
                    case 33776:
                        {
                            // if healed by another unit (victim)
                            if (this == victim)
                                return false;
 
                            // dont allow non-positive dots to proc
                            if (!procSpell || !procSpell->IsPositive())
                                return false;
 
                            // heal amount
                            basepoints0 = int32(CalculatePct(std::min(damage, GetMaxHealth() - GetHealth()), triggerAmount));
                            target = this;
 
                            if (basepoints0)
                                triggered_spell_id = 31786;
                            break;
                        }
                    // Paladin Tier 6 Trinket (Ashtongue Talisman of Zeal)
                    case 40470:
                        {
                            if (!procSpell)
                                return false;
 
                            float chance = 0.0f;
 
                            // Flash of light/Holy light
                            if (procSpell->SpellFamilyFlags[0] & 0xC0000000)
                            {
                                triggered_spell_id = 40471;
                                chance = 15.0f;
                            }
                            // Judgement (any)
                            else if (procSpell->SpellFamilyFlags[0] & 0x800000)
                            {
                                triggered_spell_id = 40472;
                                chance = 50.0f;
                            }
                            else
                                return false;
 
                            if (!roll_chance_f(chance))
                                return false;
 
                            break;
                        }
                    // Glyph of Holy Light
                    case 54937:
                        {
                            triggered_spell_id = 54968;
                            basepoints0 = CalculatePct(int32(damage), triggerAmount);
                            break;
                        }
                    // Item - Paladin T8 Holy 2P Bonus
                    case 64890:
                        {
                            triggered_spell_id = 64891;
                            basepoints0 = triggerAmount * damage / 300;
                            break;
                        }
                    case 71406: // Tiny Abomination in a Jar
                    case 71545: // Tiny Abomination in a Jar (Heroic)
                        {
                            if (!victim || !victim->IsAlive())
                                return false;
 
                            CastSpell(this, 71432, true, nullptr, triggeredByAura);
 
                            Aura const* dummy = GetAura(71432);
                            if (!dummy || dummy->GetStackAmount() < (dummySpell->Id == 71406 ? 8 : 7))
                                return false;
 
                            RemoveAurasDueToSpell(71432);
                            triggered_spell_id = 71433;  // default main hand attack
                            // roll if offhand
                            if (Player const* player = ToPlayer())
                                if (player->GetWeaponForAttack(OFF_ATTACK, true) && urand(0, 1))
                                    triggered_spell_id = 71434;
                            target = victim;
                            break;
                        }
                    // Item - Icecrown 25 Normal Dagger Proc
                    case 71880:
                        {
                            switch (getPowerType())
                            {
                                case POWER_MANA:
                                    triggered_spell_id = 71881;
                                    break;
                                case POWER_RAGE:
                                    triggered_spell_id = 71883;
                                    break;
                                case POWER_ENERGY:
                                    triggered_spell_id = 71882;
                                    break;
                                case POWER_RUNIC_POWER:
                                    triggered_spell_id = 71884;
                                    break;
                                default:
                                    return false;
                            }
                            break;
                        }
                    // Item - Icecrown 25 Heroic Dagger Proc
                    case 71892:
                        {
                            switch (getPowerType())
                            {
                                case POWER_MANA:
                                    triggered_spell_id = 71888;
                                    break;
                                case POWER_RAGE:
                                    triggered_spell_id = 71886;
                                    break;
                                case POWER_ENERGY:
                                    triggered_spell_id = 71887;
                                    break;
                                case POWER_RUNIC_POWER:
                                    triggered_spell_id = 71885;
                                    break;
                                default:
                                    return false;
                            }
                            break;
                        }
                }
                break;
            }
        case SPELLFAMILY_SHAMAN:
            {
                switch (dummySpell->Id)
                {
                    // Tidal Force
                    case 55198:
                        {
                            // Remove aura stack from  caster
                            RemoveAuraFromStack(55166);
                            // drop charges
                            return false;
                        }
                    // Totemic Power (The Earthshatterer set)
                    case 28823:
                        {
                            if (!victim)
                                return false;
 
                            // Set class defined buff
                            switch (victim->getClass())
                            {
                                case CLASS_PALADIN:
                                case CLASS_PRIEST:
                                case CLASS_SHAMAN:
                                case CLASS_DRUID:
                                    triggered_spell_id = 28824;     // Increases the friendly target's mana regeneration by $s1 per 5 sec. for $d.
                                    break;
                                case CLASS_MAGE:
                                case CLASS_WARLOCK:
                                    triggered_spell_id = 28825;     // Increases the friendly target's spell damage and healing by up to $s1 for $d.
                                    break;
                                case CLASS_HUNTER:
                                case CLASS_ROGUE:
                                    triggered_spell_id = 28826;     // Increases the friendly target's attack power by $s1 for $d.
                                    break;
                                case CLASS_WARRIOR:
                                    triggered_spell_id = 28827;     // Increases the friendly target's armor
                                    break;
                                default:
                                    return false;
                            }
                            break;
                        }
                    // Lesser Healing Wave (Totem of Flowing Water Relic)
                    case 28849:
                        {
                            target = this;
                            triggered_spell_id = 28850;
                            break;
                        }
                    // Windfury Weapon (Passive) 1-8 Ranks
                    case 33757:
                        {
                            Player* player = ToPlayer();
                            if (!player || !castItem || !castItem->IsEquipped() || !victim || !victim->IsAlive())
                                return false;
 
                            if (triggeredByAura->GetBase() && castItem->GetGUID() != triggeredByAura->GetBase()->GetCastItemGUID())
                                return false;
 
                            WeaponAttackType attType = WeaponAttackType(player->GetAttackBySlot(castItem->GetSlot()));
                            if ((attType != BASE_ATTACK && attType != OFF_ATTACK)
                                    || (attType == BASE_ATTACK && procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK)
                                    || (attType == OFF_ATTACK && procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK))
                                return false;
 
                            // Now amount of extra power stored in 1 effect of Enchant spell
                            // Get it by item enchant id
                            uint32 spellId;
                            switch (castItem->GetEnchantmentId(EnchantmentSlot(TEMP_ENCHANTMENT_SLOT)))
                            {
                                case 283:
                                    spellId =  8232;
                                    break;   // 1 Rank
                                case 284:
                                    spellId =  8235;
                                    break;   // 2 Rank
                                case 525:
                                    spellId = 10486;
                                    break;   // 3 Rank
                                case 1669:
                                    spellId = 16362;
                                    break;   // 4 Rank
                                case 2636:
                                    spellId = 25505;
                                    break;   // 5 Rank
                                case 3785:
                                    spellId = 58801;
                                    break;   // 6 Rank
                                case 3786:
                                    spellId = 58803;
                                    break;   // 7 Rank
                                case 3787:
                                    spellId = 58804;
                                    break;   // 8 Rank
                                default:
                                    {
                                        LOG_ERROR("entities.unit", "Unit::HandleDummyAuraProc: non handled item enchantment (rank?) {} for spell id: {} (Windfury)",
                                                       castItem->GetEnchantmentId(EnchantmentSlot(TEMP_ENCHANTMENT_SLOT)), dummySpell->Id);
                                        return false;
                                    }
                            }
 
                            SpellInfo const* windfurySpellInfo = sSpellMgr->GetSpellInfo(spellId);
                            if (!windfurySpellInfo)
                            {
                                LOG_ERROR("entities.unit", "Unit::HandleDummyAuraProc: non-existing spell id: {} (Windfury)", spellId);
                                return false;
                            }
 
                            int32 extra_attack_power = CalculateSpellDamage(victim, windfurySpellInfo, 1);
 
                            // Value gained from additional AP
                            basepoints0 = int32(extra_attack_power / 14.0f * GetAttackTime(attType) / 1000);
 
                            if (procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK)
                                triggered_spell_id = 25504;
 
                            if (procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK)
                                triggered_spell_id = 33750;
 
                            // custom cooldown processing case
                            if (player->HasSpellCooldown(dummySpell->Id))
                                return false;
 
                            // apply cooldown before cast to prevent processing itself
                            player->AddSpellCooldown(dummySpell->Id, 0, 3 * IN_MILLISECONDS);
 
                            // Attack Twice
                            for (uint32 i = 0; i < 2; ++i)
                                CastCustomSpell(victim, triggered_spell_id, &basepoints0, nullptr, nullptr, true, castItem, triggeredByAura);
 
                            return true;
                        }
                    // Shaman Tier 6 Trinket
                    case 40463:
                        {
                            if (!procSpell)
                                return false;
 
                            float chance;
                            if (procSpell->SpellFamilyFlags[0] & 0x1)
                            {
                                triggered_spell_id = 40465;         // Lightning Bolt
                                chance = 15.0f;
                            }
                            else if (procSpell->SpellFamilyFlags[0] & 0x80)
                            {
                                triggered_spell_id = 40465;         // Lesser Healing Wave
                                chance = 10.0f;
                            }
                            else if (procSpell->SpellFamilyFlags[1] & 0x00000010)
                            {
                                triggered_spell_id = 40466;         // Stormstrike
                                chance = 50.0f;
                            }
                            else
                                return false;
 
                            if (!roll_chance_f(chance))
                                return false;
 
                            target = this;
                            break;
                        }
                    // Glyph of Healing Wave
                    case 55440:
                        {
                            // Not proc from self heals
                            if (this == victim)
                                return false;
                            basepoints0 = CalculatePct(int32(damage), triggerAmount);
                            target = this;
                            triggered_spell_id = 55533;
                            break;
                        }
                    // Spirit Hunt
                    case 58877:
                        {
                            // Cast on owner
                            target = GetOwner();
                            if (!target)
                                return false;
                            basepoints0 = CalculatePct(int32(damage), triggerAmount);
                            triggered_spell_id = 58879;
                            // Heal wolf
                            CastCustomSpell(this, triggered_spell_id, &basepoints0, nullptr, nullptr, true, castItem, triggeredByAura, originalCaster);
                            break;
                        }
                    // Shaman T8 Elemental 4P Bonus
                    case 64928:
                        {
                            basepoints0 = CalculatePct(int32(damage), triggerAmount);
                            triggered_spell_id = 64930;            // Electrified
                            break;
                        }
                    // Shaman T9 Elemental 4P Bonus
                    case 67228:
                        {
                            // Lava Burst
                            if (procSpell->SpellFamilyFlags[1] & 0x1000)
                            {
                                triggered_spell_id = 71824;
                                SpellInfo const* triggeredSpell = sSpellMgr->GetSpellInfo(triggered_spell_id);
                                if (!triggeredSpell)
                                    return false;
                                basepoints0 = CalculatePct(int32(damage), triggerAmount) / (triggeredSpell->GetMaxDuration() / triggeredSpell->Effects[0].Amplitude);
                            }
                            break;
                        }
                    // Item - Shaman T10 Elemental 4P Bonus
                    case 70817:
                        {
                            if (!target)
                                return false;
                            // try to find spell Flame Shock on the target
                            if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_SHAMAN, 0x10000000, 0x0, 0x0, GetGUID()))
                            {
                                Aura* flameShock  = aurEff->GetBase();
                                int32 extraTime = 2 * aurEff->GetAmplitude();
                                flameShock->SetMaxDuration(flameShock->GetMaxDuration() + extraTime);
                                flameShock->SetDuration(flameShock->GetDuration() + extraTime);
 
                                return true;
                            }
                            // if not found Flame Shock
                            return false;
                        }
                        break;
                }
                // Frozen Power
                if (dummySpell->SpellIconID == 3780)
                {
                    if (!target)
                        return false;
                    if (GetDistance(target) < 15.0f)
                        return false;
                    float chance = (float)triggerAmount;
                    if (!roll_chance_f(chance))
                        return false;
 
                    triggered_spell_id = 63685;
                    break;
                }
                // Ancestral Awakening
                if (dummySpell->SpellIconID == 3065)
                {
                    triggered_spell_id = 52759;
                    basepoints0 = CalculatePct(int32(damage), triggerAmount);
                    target = this;
                    break;
                }
                // Flametongue Weapon (Passive)
                if (dummySpell->SpellFamilyFlags[0] & 0x200000)
                {
                    if (GetTypeId() != TYPEID_PLAYER  || !victim || !victim->IsAlive() || !castItem || !castItem->IsEquipped())
                        return false;
 
                    WeaponAttackType attType = WeaponAttackType(Player::GetAttackBySlot(castItem->GetSlot()));
                    if ((attType != BASE_ATTACK && attType != OFF_ATTACK)
                            || (attType == BASE_ATTACK && procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK)
                            || (attType == OFF_ATTACK && procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK))
                        return false;
 
                    float fire_onhit = float(CalculatePct(dummySpell->Effects[EFFECT_0]. CalcValue(), 1.0f));
 
                    float add_spellpower = (float)(SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_FIRE)
                                                   + victim->SpellBaseDamageBonusTaken(SPELL_SCHOOL_MASK_FIRE));
 
                    // 1.3speed = 5%, 2.6speed = 10%, 4.0 speed = 15%, so, 1.0speed = 3.84%
                    ApplyPct(add_spellpower, 3.84f);
 
                    // Enchant on Off-Hand and ready?
                    if (castItem->GetSlot() == EQUIPMENT_SLOT_OFFHAND && procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK)
                    {
                        float BaseWeaponSpeed = GetAttackTime(OFF_ATTACK) / 1000.0f;
 
                        // Value1: add the tooltip damage by swingspeed + Value2: add spelldmg by swingspeed
                        basepoints0 = int32((fire_onhit * BaseWeaponSpeed) + (add_spellpower * BaseWeaponSpeed));
                        triggered_spell_id = 10444;
                    }
 
                    // Enchant on Main-Hand and ready?
                    else if (castItem->GetSlot() == EQUIPMENT_SLOT_MAINHAND && procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK)
                    {
                        float BaseWeaponSpeed = GetAttackTime(BASE_ATTACK) / 1000.0f;
 
                        // Value1: add the tooltip damage by swingspeed +  Value2: add spelldmg by swingspeed
                        basepoints0 = int32((fire_onhit * BaseWeaponSpeed) + (add_spellpower * BaseWeaponSpeed));
                        triggered_spell_id = 10444;
                    }
 
                    // If not ready, we should  return, shouldn't we?!
                    else
                        return false;
 
                    CastCustomSpell(victim, triggered_spell_id, &basepoints0, nullptr, nullptr, true, castItem, triggeredByAura);
                    return true;
                }
                // Improved Water Shield
                if (dummySpell->SpellIconID == 2287)
                {
                    if (!procSpell)
                        return false;
 
                    // Default chance for Healing Wave and Riptide
                    float chance = (float)triggeredByAura->GetAmount();
 
                    if (procSpell->SpellFamilyFlags[0] & 0x80)
                        // Lesser Healing Wave - 0.6 of default
                        chance *= 0.6f;
                    else if (procSpell->SpellFamilyFlags[0] & 0x100)
                        // Chain heal - 0.3 of default
                        chance *= 0.3f;
 
                    if (!roll_chance_f(chance))
                        return false;
 
                    // Water Shield
                    if (AuraEffect const* aurEff = GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_SHAMAN, 0, 0x00000020, 0))
                    {
                        uint32 spell = aurEff->GetSpellInfo()->Effects[aurEff->GetEffIndex()].TriggerSpell;
                        CastSpell(this, spell, true, castItem, triggeredByAura);
                        return true;
                    }
                    return false;
                }
                // Lightning Overload
                if (dummySpell->SpellIconID == 2018)            // only this spell have SpellFamily Shaman SpellIconID == 2018 and dummy aura
                {
                    if(!procSpell || GetTypeId() != TYPEID_PLAYER || !victim)
                        return false;
 
                    if (procEx & PROC_EX_CRITICAL_HIT)
                        damage /= 2;
 
                    do
                    {
                        uint32 spell = 0;
 
                        if (procSpell->SpellFamilyFlags[0] & 0x2)
                        {
                            // 1/3 of 33% if 11%
                            if (!roll_chance_i(33))
                                return false;
 
                            spell = 45297;
                        }
                        else
                            spell = 45284;
 
                        // do not reduce damage-spells have correct basepoints
                        damage /= 2;
                        int32 dmg = damage;
 
                        // Cast
                        CastCustomSpell(victim, spell, &dmg, 0, 0, true, castItem, triggeredByAura);
                    } while (roll_chance_i(33));
                    return true;
                }
                // Static Shock
                if (dummySpell->SpellIconID == 3059)
                {
                    // Lightning Shield
                    if (AuraEffect const* aurEff = GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_SHAMAN, 0x400, 0, 0))
                    {
                        uint32 spell = sSpellMgr->GetSpellWithRank(26364, aurEff->GetSpellInfo()->GetRank());
                        CastSpell(target, spell, true, castItem, triggeredByAura);
                        aurEff->GetBase()->DropCharge();
                        return true;
                    }
                    return false;
                }
                break;
            }
        case SPELLFAMILY_DEATHKNIGHT:
            {
                // Improved Blood Presence
                if (dummySpell->SpellIconID == 2636)
                {
                    if (GetTypeId() != TYPEID_PLAYER)
                        return false;
                    basepoints0 = CalculatePct(int32(damage), triggerAmount);
                    break;
                }
                // Butchery
                if (dummySpell->SpellIconID == 2664)
                {
                    basepoints0 = triggerAmount;
                    triggered_spell_id = 50163;
                    target = this;
                    break;
                }
                // Mark of Blood
                if (dummySpell->Id == 49005)
                {
                    // TODO: need more info (cooldowns/PPM)
                    triggered_spell_id = 61607;
                    break;
                }
                // Unholy Blight
                if (dummySpell->Id == 49194)
                {
                    triggered_spell_id = 50536;
                    SpellInfo const* unholyBlight = sSpellMgr->GetSpellInfo(triggered_spell_id);
                    if (!unholyBlight || !victim)
                        return false;
 
                    basepoints0 = CalculatePct(int32(damage), triggerAmount);
 
                    //Glyph of Unholy Blight
                    if (AuraEffect* glyph = GetAuraEffect(63332, 0))
                        AddPct(basepoints0, glyph->GetAmount());
 
                    basepoints0 = basepoints0 / (unholyBlight->GetMaxDuration() / unholyBlight->Effects[0].Amplitude);
                    victim->CastDelayedSpellWithPeriodicAmount(this, triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE, basepoints0);
                    return true;
                }
                // Vendetta
                if (dummySpell->SpellFamilyFlags[0] & 0x10000)
                {
                    basepoints0 = int32(CountPctFromMaxHealth(triggerAmount));
                    triggered_spell_id = 50181;
                    target = this;
                    break;
                }
                // Necrosis
                if (dummySpell->SpellIconID == 2709)
                {
                    basepoints0 = CalculatePct(int32(damage), triggerAmount);
                    triggered_spell_id = 51460;
                    break;
                }
                // Threat of Thassarian
                if (dummySpell->SpellIconID == 2023)
                {
                    // Must Dual Wield
                    if (!procSpell || !haveOffhandWeapon())
                        return false;
                    // Chance as basepoints for dummy aura
                    if (!roll_chance_i(triggerAmount))
                        return false;
 
                    switch (procSpell->Id)
                    {
                        // Obliterate
                        case 49020:
                            triggered_spell_id = 66198;
                            break;                            // Rank 1
                        case 51423:
                            triggered_spell_id = 66972;
                            break;                            // Rank 2
                        case 51424:
                            triggered_spell_id = 66973;
                            break;                            // Rank 3
                        case 51425:
                            triggered_spell_id = 66974;
                            break;                            // Rank 4
 
                        // Frost Strike
                        case 49143:
                            triggered_spell_id = 66196;
                            break;                            // Rank 1
                        case 51416:
                            triggered_spell_id = 66958;
                            break;                            // Rank 2
                        case 51417:
                            triggered_spell_id = 66959;
                            break;                            // Rank 3
                        case 51418:
                            triggered_spell_id = 66960;
                            break;                            // Rank 4
                        case 51419:
                            triggered_spell_id = 66961;
                            break;                            // Rank 5
                        case 55268:
                            triggered_spell_id = 66962;
                            break;                            // Rank 6
 
                        // Plague Strike
                        case 45462:
                            triggered_spell_id = 66216;
                            break;                            // Rank 1
                        case 49917:
                            triggered_spell_id = 66988;
                            break;                            // Rank 2
                        case 49918:
                            triggered_spell_id = 66989;
                            break;                            // Rank 3
                        case 49919:
                            triggered_spell_id = 66990;
                            break;                            // Rank 4
                        case 49920:
                            triggered_spell_id = 66991;
                            break;                            // Rank 5
                        case 49921:
                            triggered_spell_id = 66992;
                            break;                            // Rank 6
 
                        // Death Strike
                        case 49998:
                            triggered_spell_id = 66188;
                            break;                            // Rank 1
                        case 49999:
                            triggered_spell_id = 66950;
                            break;                            // Rank 2
                        case 45463:
                            triggered_spell_id = 66951;
                            break;                            // Rank 3
                        case 49923:
                            triggered_spell_id = 66952;
                            break;                            // Rank 4
                        case 49924:
                            triggered_spell_id = 66953;
                            break;                            // Rank 5
 
                        // Rune Strike
                        case 56815:
                            triggered_spell_id = 66217;
                            break;                            // Rank 1
 
                        // Blood Strike
                        case 45902:
                            triggered_spell_id = 66215;
                            break;                            // Rank 1
                        case 49926:
                            triggered_spell_id = 66975;
                            break;                            // Rank 2
                        case 49927:
                            triggered_spell_id = 66976;
                            break;                            // Rank 3
                        case 49928:
                            triggered_spell_id = 66977;
                            break;                            // Rank 4
                        case 49929:
                            triggered_spell_id = 66978;
                            break;                            // Rank 5
                        case 49930:
                            triggered_spell_id = 66979;
                            break;                            // Rank 6
                        default:
                            return false;
                    }
 
                    // This should do, restore spell mod so next attack can also use this!
                    // crit chance for first strike is already computed
                    ToPlayer()->RestoreSpellMods(m_currentSpells[CURRENT_GENERIC_SPELL], 51124, nullptr); // Killing Machine
                    ToPlayer()->RestoreSpellMods(m_currentSpells[CURRENT_GENERIC_SPELL], 49796, nullptr); // Deathchill
 
                    // Xinef: Somehow basepoints are divided by 2 which is later divided by 2 (offhand multiplier)
                    SpellInfo const* triggerEntry = sSpellMgr->GetSpellInfo(triggered_spell_id);
                    if (triggerEntry->SchoolMask & SPELL_SCHOOL_MASK_NORMAL)
                        basepoints0 = triggerEntry->Effects[EFFECT_0].BasePoints * 2;
 
                    SetCantProc(true);
                    if(basepoints0)
                        CastCustomSpell(target, triggered_spell_id, &basepoints0, nullptr, nullptr, true, castItem, triggeredByAura, originalCaster);
                    else
                        CastSpell(target, triggered_spell_id, true, castItem, triggeredByAura, originalCaster);
                    SetCantProc(false);
                    return true;
                }
                // Runic Power Back on Snare/Root
                if (dummySpell->Id == 61257)
                {
                    // only for spells and hit/crit (trigger start always) and not start from self casted spells
                    if (procSpell == 0 || !(procEx & (PROC_EX_NORMAL_HIT | PROC_EX_CRITICAL_HIT)) || this == victim)
                        return false;
                    // Need snare or root mechanic
                    if (!(procSpell->GetAllEffectsMechanicMask() & ((1 << MECHANIC_ROOT) | (1 << MECHANIC_SNARE))))
                        return false;
                    triggered_spell_id = 61258;
                    target = this;
                    break;
                }
                // Sudden Doom
                if (dummySpell->SpellIconID == 1939 && GetTypeId() == TYPEID_PLAYER)
                {
                    SpellChainNode const* chain = nullptr;
                    // get highest rank of the Death Coil spell
                    PlayerSpellMap const& sp_list = ToPlayer()->GetSpellMap();
                    for (PlayerSpellMap::const_iterator itr = sp_list.begin(); itr != sp_list.end(); ++itr)
                    {
                        // check if shown in spell book
                        if (!itr->second->Active || !itr->second->IsInSpec(ToPlayer()->GetActiveSpec()) || itr->second->State == PLAYERSPELL_REMOVED)
                            continue;
 
                        SpellInfo const* spellProto = sSpellMgr->GetSpellInfo(itr->first);
                        if (!spellProto)
                            continue;
 
                        if (spellProto->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT
                                && spellProto->SpellFamilyFlags[0] & 0x2000)
                        {
                            SpellChainNode const* newChain = sSpellMgr->GetSpellChainNode(itr->first);
 
                            // No chain entry or entry lower than found entry
                            if (!chain || !newChain || (chain->rank < newChain->rank))
                            {
                                triggered_spell_id = itr->first;
                                chain = newChain;
                            }
                            else
                                continue;
                            // Found spell is last in chain - do not need to look more
                            // Optimisation for most common case
                            if (chain && chain->last->Id == itr->first)
                                break;
                        }
                    }
                }
                break;
            }
        case SPELLFAMILY_POTION:
            {
                // alchemist's stone
                if (dummySpell->Id == 17619)
                {
                    if (procSpell->SpellFamilyName == SPELLFAMILY_POTION)
                    {
                        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; i++)
                        {
                            if (procSpell->Effects[i].Effect == SPELL_EFFECT_HEAL)
                            {
                                triggered_spell_id = 21399;
                            }
                            else if (procSpell->Effects[i].Effect == SPELL_EFFECT_ENERGIZE)
                            {
                                triggered_spell_id = 21400;
                            }
                            else
                                continue;
 
                            basepoints0 = int32(CalculateSpellDamage(this, procSpell, i) * 0.4f);
                            CastCustomSpell(this, triggered_spell_id, &basepoints0, nullptr, nullptr, true, nullptr, triggeredByAura);
                        }
                        return true;
                    }
                }
                break;
            }
        case SPELLFAMILY_PET:
            {
                switch (dummySpell->SpellIconID)
                {
                    // Guard Dog
                    case 201:
                        {
                            if (!victim)
                                return false;
 
                            triggered_spell_id = 54445;
                            target = this;
                            float addThreat = float(CalculatePct(procSpell->Effects[0].CalcValue(this), triggerAmount));
                            victim->AddThreat(this, addThreat);
                            break;
                        }
                    // Silverback
                    case 1582:
                        triggered_spell_id = dummySpell->Id == 62765 ? 62801 : 62800;
                        target = this;
                        break;
                }
                break;
            }
        default:
            break;
    }
 
    // if not handled by custom case, get triggered spell from dummySpell proto
    if (!triggered_spell_id)
        triggered_spell_id = dummySpell->Effects[triggeredByAura->GetEffIndex()].TriggerSpell;
 
    // processed charge only counting case
    if (!triggered_spell_id)
        return true;
 
    SpellInfo const* triggerEntry = sSpellMgr->GetSpellInfo(triggered_spell_id);
    if (!triggerEntry)
    {
        LOG_ERROR("entities.unit", "Unit::HandleDummyAuraProc: Spell {} has non-existing triggered spell {}", dummySpell->Id, triggered_spell_id);
        return false;
    }
 
    if (cooldown_spell_id == 0)
        cooldown_spell_id = triggered_spell_id;
 
    if (cooldown)
    {
        if (HasSpellCooldown(cooldown_spell_id))
            return false;
 
        AddSpellCooldown(cooldown_spell_id, 0, cooldown);
    }
 
    if(basepoints0)
        CastCustomSpell(target, triggered_spell_id, &basepoints0, nullptr, nullptr, true, castItem, triggeredByAura, originalCaster);
    else
        CastSpell(target, triggered_spell_id, true, castItem, triggeredByAura, originalCaster);
 
    return true;
}

◆ HandleEmoteCommand()

void Unit::HandleEmoteCommand ( uint32 emoteId )

Definition at line 1958 of file Unit.cpp.

{
    WorldPackets::Chat::Emote packet;
    packet.EmoteID = emoteId;
    packet.Guid = GetGUID();
    SendMessageToSet(packet.Write(), true);
}

◆ HandleOverrideClassScriptAuraProc()

bool Unit::HandleOverrideClassScriptAuraProc	(	Unit *	victim,
		uint32	damage,
		AuraEffect *	triggeredByAura,
		SpellInfo const *	procSpell,
		uint32	cooldown
	)

private

Definition at line 9822 of file Unit.cpp.

{
    int32 scriptId = triggeredByAura->GetMiscValue();
 
    if (!victim || !victim->IsAlive())
        return false;
 
    Item* castItem = triggeredByAura->GetBase()->GetCastItemGUID() && GetTypeId() == TYPEID_PLAYER
                     ? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : nullptr;
 
    uint32 triggered_spell_id = 0;
 
    switch (scriptId)
    {
        case 836:                                           // Improved Blizzard (Rank 1)
            {
                if (!procSpell || procSpell->SpellVisual[0] != 9487)
                    return false;
                triggered_spell_id = 12484;
                break;
            }
        case 988:                                           // Improved Blizzard (Rank 2)
            {
                if (!procSpell || procSpell->SpellVisual[0] != 9487)
                    return false;
                triggered_spell_id = 12485;
                break;
            }
        case 989:                                           // Improved Blizzard (Rank 3)
            {
                if (!procSpell || procSpell->SpellVisual[0] != 9487)
                    return false;
                triggered_spell_id = 12486;
                break;
            }
        case 4533:                                          // Dreamwalker Raiment 2 pieces bonus
            {
                // Chance 50%
                if (!roll_chance_i(50))
                    return false;
 
                switch (victim->getPowerType())
                {
                    case POWER_MANA:
                        triggered_spell_id = 28722;
                        break;
                    case POWER_RAGE:
                        triggered_spell_id = 28723;
                        break;
                    case POWER_ENERGY:
                        triggered_spell_id = 28724;
                        break;
                    default:
                        return false;
                }
                break;
            }
        case 4537:                                          // Dreamwalker Raiment 6 pieces bonus
            triggered_spell_id = 28750;                     // Blessing of the Claw
            break;
        case 5497:                                          // Improved Mana Gems
            triggered_spell_id = 37445;                     // Mana Surge
            break;
        case 7010:  // Revitalize - can proc on full hp target
        case 7011:
        case 7012:
            {
                if (!roll_chance_i(triggeredByAura->GetAmount()))
                    return false;
                switch (victim->getPowerType())
                {
                    case POWER_MANA:
                        triggered_spell_id = 48542;
                        break;
                    case POWER_RAGE:
                        triggered_spell_id = 48541;
                        break;
                    case POWER_ENERGY:
                        triggered_spell_id = 48540;
                        break;
                    case POWER_RUNIC_POWER:
                        triggered_spell_id = 48543;
                        break;
                    default:
                        break;
                }
                break;
            }
        default:
            break;
    }
 
    // not processed
    if (!triggered_spell_id)
        return false;
 
    // standard non-dummy case
    SpellInfo const* triggerEntry = sSpellMgr->GetSpellInfo(triggered_spell_id);
 
    if (!triggerEntry)
    {
        LOG_ERROR("entities.unit", "Unit::HandleOverrideClassScriptAuraProc: Spell {} triggering for class script id {}", triggered_spell_id, scriptId);
        return false;
    }
 
    if (cooldown)
    {
        if (HasSpellCooldown(triggered_spell_id))
            return false;
 
        AddSpellCooldown(triggered_spell_id, 0, cooldown);
    }
 
    CastSpell(victim, triggered_spell_id, true, castItem, triggeredByAura);
 
    return true;
}

◆ HandleProcExtraAttackFor()

void Unit::HandleProcExtraAttackFor	(	Unit *	victim,
		uint32	count
	)

Definition at line 2706 of file Unit.cpp.

{
    while (count)
    {
        --count;
        AttackerStateUpdate(victim, BASE_ATTACK, true);
    }
}

◆ HandleProcTriggerSpell()

bool Unit::HandleProcTriggerSpell	(	Unit *	victim,
		uint32	damage,
		AuraEffect *	triggeredByAura,
		SpellInfo const *	procSpell,
		uint32	procFlag,
		uint32	procEx,
		uint32	cooldown,
		uint32	procPhase,
		ProcEventInfo &	eventInfo
	)

private

Definition at line 8873 of file Unit.cpp.

{
    // Get triggered aura spell info
    SpellInfo const* auraSpellInfo = triggeredByAura->GetSpellInfo();
 
    // Basepoints of trigger aura
    int32 triggerAmount = triggeredByAura->GetAmount();
 
    // Set trigger spell id, target, custom basepoints
    uint32 trigger_spell_id = auraSpellInfo->Effects[triggeredByAura->GetEffIndex()].TriggerSpell;
 
    Unit*  target = nullptr;
    int32  basepoints0 = 0;
 
    if (triggeredByAura->GetAuraType() == SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE)
        basepoints0 = triggerAmount;
 
    Item* castItem = triggeredByAura->GetBase()->GetCastItemGUID() && GetTypeId() == TYPEID_PLAYER
                     ? ToPlayer()->GetItemByGuid(triggeredByAura->GetBase()->GetCastItemGUID()) : nullptr;
 
    // Try handle unknown trigger spells
    //if (sSpellMgr->GetSpellInfo(trigger_spell_id) == nullptr)
    {
        switch (auraSpellInfo->SpellFamilyName)
        {
            case SPELLFAMILY_GENERIC:
                switch (auraSpellInfo->Id)
                {
                    case 43820:             // Charm of the Witch Doctor (Amani Charm of the Witch Doctor trinket)
                        // Pct value stored in dummy
                        if (!victim)
                            return false;
                        basepoints0 = victim->GetCreateHealth() * auraSpellInfo->Effects[1].CalcValue() / 100;
                        target = victim;
                        break;
                    case 57345:             // Darkmoon Card: Greatness
                        {
                            float stat = 0.0f;
                            // strength
                            if (GetStat(STAT_STRENGTH) > stat) { trigger_spell_id = 60229; stat = GetStat(STAT_STRENGTH); }
                            // agility
                            if (GetStat(STAT_AGILITY)  > stat) { trigger_spell_id = 60233; stat = GetStat(STAT_AGILITY);  }
                            // intellect
                            if (GetStat(STAT_INTELLECT) > stat) { trigger_spell_id = 60234; stat = GetStat(STAT_INTELLECT);}
                            // spirit
                            if (GetStat(STAT_SPIRIT)   > stat) { trigger_spell_id = 60235;                               }
                            break;
                        }
                    case 67702:             // Death's Choice, Item - Coliseum 25 Normal Melee Trinket
                        {
                            if (!damage)
                                return false;
                            float stat = 0.0f;
                            // strength
                            if (GetStat(STAT_STRENGTH) > stat) { trigger_spell_id = 67708; stat = GetStat(STAT_STRENGTH); }
                            // agility
                            if (GetStat(STAT_AGILITY)  > stat) { trigger_spell_id = 67703;                               }
                            break;
                        }
                    case 67771:             // Death's Choice (heroic), Item - Coliseum 25 Heroic Melee Trinket
                        {
                            if (!damage)
                                return false;
                            float stat = 0.0f;
                            // strength
                            if (GetStat(STAT_STRENGTH) > stat) { trigger_spell_id = 67773; stat = GetStat(STAT_STRENGTH); }
                            // agility
                            if (GetStat(STAT_AGILITY)  > stat) { trigger_spell_id = 67772;                               }
                            break;
                        }
                    // Mana Drain Trigger
                    case 27522:
                    case 40336:
                        {
                            // On successful melee or ranged attack gain $29471s1 mana and if possible drain $27526s1 mana from the target.
                            if (IsAlive())
                                CastSpell(this, 29471, true, castItem, triggeredByAura);
                            if (victim && victim->IsAlive())
                                CastSpell(victim, 27526, true, castItem, triggeredByAura);
                            return true;
                        }
                    // Forge of Souls, Devourer of Souls, Mirrored Soul
                    case 69023:
                        {
                            int32 dmg = damage * 0.45f;
                            if (dmg > 0)
                                if (Aura* a = GetAura(69023))
                                    if (Unit* c = a->GetCaster())
                                        CastCustomSpell(c, 69034, &dmg, 0, 0, true);
                            return true;
                        }
                    // Soul-Trader Beacon proc aura
                    case 50051:
                        {
                            if (!victim)
                                return false;
 
                            if (Creature* cr = ObjectAccessor::GetCreature(*this, m_SummonSlot[SUMMON_SLOT_MINIPET]))
                                cr->CastSpell(victim, 50101, true);
 
                            return false;
                        }
                }
                break;
            case SPELLFAMILY_MAGE:
                if (auraSpellInfo->SpellIconID == 2127)     // Blazing Speed
                {
                    switch (auraSpellInfo->Id)
                    {
                        case 31641:  // Rank 1
                        case 31642:  // Rank 2
                            trigger_spell_id = 31643;
                            break;
                        default:
                            LOG_ERROR("entities.unit", "Unit::HandleProcTriggerSpell: Spell {} miss posibly Blazing Speed", auraSpellInfo->Id);
                            return false;
                    }
                }
                else if (auraSpellInfo->Id == 71761) // Deep Freeze Immunity State (only permanent)
                {
                    Creature* creature = victim->ToCreature();
                    if (!creature || !creature->HasMechanicTemplateImmunity(1 << (MECHANIC_STUN - 1)))
                        return false;
                }
                break;
            case SPELLFAMILY_WARLOCK:
                {
                    // Nether Protection
                    if (auraSpellInfo->SpellIconID == 1985)
                    {
                        if (!procSpell)
                            return false;
                        switch (GetFirstSchoolInMask(procSpell->GetSchoolMask()))
                        {
                            case SPELL_SCHOOL_NORMAL:
                                return false;                   // ignore
                            case SPELL_SCHOOL_HOLY:
                                trigger_spell_id = 54370;
                                break;
                            case SPELL_SCHOOL_FIRE:
                                trigger_spell_id = 54371;
                                break;
                            case SPELL_SCHOOL_NATURE:
                                trigger_spell_id = 54375;
                                break;
                            case SPELL_SCHOOL_FROST:
                                trigger_spell_id = 54372;
                                break;
                            case SPELL_SCHOOL_SHADOW:
                                trigger_spell_id = 54374;
                                break;
                            case SPELL_SCHOOL_ARCANE:
                                trigger_spell_id = 54373;
                                break;
                            default:
                                return false;
                        }
                    }
                    break;
                }
            case SPELLFAMILY_PRIEST:
                {
                    // Blessed Recovery
                    if (auraSpellInfo->SpellIconID == 1875)
                    {
                        switch (auraSpellInfo->Id)
                        {
                            case 27811:
                                trigger_spell_id = 27813;
                                break;
                            case 27815:
                                trigger_spell_id = 27817;
                                break;
                            case 27816:
                                trigger_spell_id = 27818;
                                break;
                            default:
                                LOG_ERROR("entities.unit", "Unit::HandleProcTriggerSpell: Spell {} not handled in BR", auraSpellInfo->Id);
                                return false;
                        }
                        basepoints0 = CalculatePct(int32(damage), triggerAmount) / 3;
                        target = this;
                        // Add remaining ticks to healing done
                        CastDelayedSpellWithPeriodicAmount(this, trigger_spell_id, SPELL_AURA_PERIODIC_HEAL, basepoints0);
                        return true;
                    }
                    break;
                }
            case SPELLFAMILY_DRUID:
                {
                    switch (auraSpellInfo->Id)
                    {
                        // Druid Forms Trinket
                        case 37336:
                            {
                                switch (GetShapeshiftForm())
                                {
                                    case FORM_NONE:
                                        trigger_spell_id = 37344;
                                        break;
                                    case FORM_CAT:
                                        trigger_spell_id = 37341;
                                        break;
                                    case FORM_BEAR:
                                    case FORM_DIREBEAR:
                                        trigger_spell_id = 37340;
                                        break;
                                    case FORM_TREE:
                                        trigger_spell_id = 37342;
                                        break;
                                    case FORM_MOONKIN:
                                        trigger_spell_id = 37343;
                                        break;
                                    default:
                                        return false;
                                }
                                break;
                            }
                        // Druid T9 Feral Relic (Lacerate, Swipe, Mangle, and Shred)
                        case 67353:
                            {
                                switch (GetShapeshiftForm())
                                {
                                    case FORM_CAT:
                                        trigger_spell_id = 67355;
                                        break;
                                    case FORM_BEAR:
                                    case FORM_DIREBEAR:
                                        trigger_spell_id = 67354;
                                        break;
                                    default:
                                        return false;
                                }
                                break;
                            }
                        default:
                            break;
                    }
                    break;
                }
            case SPELLFAMILY_HUNTER:
                {
                    if (auraSpellInfo->SpellIconID == 3247)     // Piercing Shots
                    {
                        if (!victim)
                            return false;
 
                        switch (auraSpellInfo->Id)
                        {
                            case 53234:  // Rank 1
                            case 53237:  // Rank 2
                            case 53238:  // Rank 3
                                trigger_spell_id = 63468;
                                break;
                            default:
                                LOG_ERROR("entities.unit", "Unit::HandleProcTriggerSpell: Spell {} miss posibly Piercing Shots", auraSpellInfo->Id);
                                return false;
                        }
                        SpellInfo const* TriggerPS = sSpellMgr->GetSpellInfo(trigger_spell_id);
                        if (!TriggerPS)
                            return false;
 
                        basepoints0 = CalculatePct(int32(damage), triggerAmount) / (TriggerPS->GetMaxDuration() / TriggerPS->Effects[0].Amplitude);
                        victim->CastDelayedSpellWithPeriodicAmount(this, trigger_spell_id, SPELL_AURA_PERIODIC_DAMAGE, basepoints0);
                        return true;
                    }
                    // Item - Hunter T9 4P Bonus (Steady Shot)
                    else if (auraSpellInfo->Id == 67151)
                    {
                        if (GetTypeId() != TYPEID_PLAYER || !ToPlayer()->GetPet())
                            return false;
 
                        target = ToPlayer()->GetPet();
                        trigger_spell_id = 68130;
                        break;
                    }
                    break;
                }
            case SPELLFAMILY_PALADIN:
                {
                    switch (auraSpellInfo->Id)
                    {
                        // Soul Preserver
                        case 60510:
                            {
                                switch (getClass())
                                {
                                    case CLASS_DRUID:
                                        trigger_spell_id = 60512;
                                        break;
                                    case CLASS_PALADIN:
                                        trigger_spell_id = 60513;
                                        break;
                                    case CLASS_PRIEST:
                                        trigger_spell_id = 60514;
                                        break;
                                    case CLASS_SHAMAN:
                                        trigger_spell_id = 60515;
                                        break;
                                }
 
                                target = this;
                                break;
                            }
                        case 37657: // Lightning Capacitor
                        case 54841: // Thunder Capacitor
                        case 67712: // Item - Coliseum 25 Normal Caster Trinket
                        case 67758: // Item - Coliseum 25 Heroic Caster Trinket
                            {
                                if (!victim || !victim->IsAlive() || GetTypeId() != TYPEID_PLAYER)
                                    return false;
 
                                uint32 stack_spell_id = 0;
                                switch (auraSpellInfo->Id)
                                {
                                    case 37657:
                                        stack_spell_id = 37658;
                                        trigger_spell_id = 37661;
                                        break;
                                    case 54841:
                                        stack_spell_id = 54842;
                                        trigger_spell_id = 54843;
                                        break;
                                    case 67712:
                                        stack_spell_id = 67713;
                                        trigger_spell_id = 67714;
                                        break;
                                    case 67758:
                                        stack_spell_id = 67759;
                                        trigger_spell_id = 67760;
                                        break;
                                }
 
                                if (cooldown && GetTypeId() == TYPEID_PLAYER)
                                {
                                    if (ToPlayer()->HasSpellCooldown(stack_spell_id))
                                        return false;
 
                                    ToPlayer()->AddSpellCooldown(stack_spell_id, 0, cooldown);
                                }
 
                                CastSpell(this, stack_spell_id, true, nullptr, triggeredByAura);
 
                                Aura* dummy = GetAura(stack_spell_id);
                                if (!dummy || dummy->GetStackAmount() < triggerAmount)
                                    return false;
 
                                RemoveAurasDueToSpell(stack_spell_id);
                                CastSpell(victim, trigger_spell_id, true, nullptr, triggeredByAura);
                                return true;
                            }
                        default:
                            // Illumination
                            if (auraSpellInfo->SpellIconID == 241)
                            {
                                if (!procSpell)
                                    return false;
                                // procspell is triggered spell but we need mana cost of original casted spell
                                uint32 originalSpellId = procSpell->Id;
                                // Holy Shock heal
                                if (procSpell->SpellFamilyFlags[1] & 0x00010000)
                                {
                                    switch (procSpell->Id)
                                    {
                                        case 25914:
                                            originalSpellId = 20473;
                                            break;
                                        case 25913:
                                            originalSpellId = 20929;
                                            break;
                                        case 25903:
                                            originalSpellId = 20930;
                                            break;
                                        case 27175:
                                            originalSpellId = 27174;
                                            break;
                                        case 33074:
                                            originalSpellId = 33072;
                                            break;
                                        case 48820:
                                            originalSpellId = 48824;
                                            break;
                                        case 48821:
                                            originalSpellId = 48825;
                                            break;
                                        default:
                                            LOG_ERROR("entities.unit", "Unit::HandleProcTriggerSpell: Spell {} not handled in HShock", procSpell->Id);
                                            return false;
                                    }
                                }
                                SpellInfo const* originalSpell = sSpellMgr->GetSpellInfo(originalSpellId);
                                if (!originalSpell)
                                {
                                    LOG_ERROR("entities.unit", "Unit::HandleProcTriggerSpell: Spell {} unknown but selected as original in Illu", originalSpellId);
                                    return false;
                                }
                                // percent stored in effect 1 (class scripts) base points
                                int32 cost = int32(originalSpell->ManaCost + CalculatePct(GetCreateMana(), originalSpell->ManaCostPercentage));
                                basepoints0 = CalculatePct(cost, auraSpellInfo->Effects[1].CalcValue());
                                trigger_spell_id = 20272;
                                target = this;
                            }
                            break;
                    }
                    break;
                }
            case SPELLFAMILY_SHAMAN:
                {
                    // Lightning Shield (overwrite non existing triggered spell call in spell.dbc
                    if (auraSpellInfo->SpellFamilyFlags[0] & 0x400)
                    {
                        // Do not proc off from self-casted items
                        if (Spell const* spell = eventInfo.GetProcSpell())
                        {
                            if (spell->m_castItemGUID && victim->GetGUID() == GetGUID())
                            {
                                return false;
                            }
                        }
 
                        trigger_spell_id = sSpellMgr->GetSpellWithRank(26364, auraSpellInfo->GetRank());
                    }
                    // Nature's Guardian
                    else if (auraSpellInfo->SpellIconID == 2013)
                    {
                        // Check health condition - should drop to less 30% (damage deal after this!)
                        if (!HealthBelowPctDamaged(30, damage))
                            return false;
 
                        if (victim && victim->IsAlive())
                            victim->GetThreatMgr().ModifyThreatByPercent(this, -10);
 
                        basepoints0 = int32(CountPctFromMaxHealth(triggerAmount));
                        trigger_spell_id = 31616;
                        target = this;
                    }
                    break;
                }
            case SPELLFAMILY_DEATHKNIGHT:
                {
                    // Acclimation
                    if (auraSpellInfo->SpellIconID == 1930)
                    {
                        if (!procSpell)
                            return false;
                        switch (GetFirstSchoolInMask(procSpell->GetSchoolMask()))
                        {
                            case SPELL_SCHOOL_NORMAL:
                                return false;                   // ignore
                            case SPELL_SCHOOL_HOLY:
                                trigger_spell_id = 50490;
                                break;
                            case SPELL_SCHOOL_FIRE:
                                trigger_spell_id = 50362;
                                break;
                            case SPELL_SCHOOL_NATURE:
                                trigger_spell_id = 50488;
                                break;
                            case SPELL_SCHOOL_FROST:
                                trigger_spell_id = 50485;
                                break;
                            case SPELL_SCHOOL_SHADOW:
                                trigger_spell_id = 50489;
                                break;
                            case SPELL_SCHOOL_ARCANE:
                                trigger_spell_id = 50486;
                                break;
                            default:
                                return false;
                        }
                    }
                    // Blood Presence (Improved)
                    else if (auraSpellInfo->Id == 63611)
                    {
                        if (GetTypeId() != TYPEID_PLAYER)
                            return false;
 
                        trigger_spell_id = 50475;
                        basepoints0 = CalculatePct(int32(damage), triggerAmount);
                    }
                    break;
                }
        }
    }
 
    // All ok. Check current trigger spell
    SpellInfo const* triggerEntry = sSpellMgr->GetSpellInfo(trigger_spell_id);
    if (!triggerEntry)
    {
        // Don't cast unknown spell
        LOG_ERROR("entities.unit", "Unit::HandleProcTriggerSpell: Spell {} (effIndex: {}) has unknown TriggerSpell {}. Unhandled custom case?", auraSpellInfo->Id, triggeredByAura->GetEffIndex(), trigger_spell_id);
        return false;
    }
 
    // not allow proc extra attack spell at extra attack
    if (triggerEntry->HasEffect(SPELL_EFFECT_ADD_EXTRA_ATTACKS))
    {
        uint32 lastExtraAttackSpell = eventInfo.GetActor()->GetLastExtraAttackSpell();
 
        // Patch 1.12.0(?) extra attack abilities can no longer chain proc themselves
        if (lastExtraAttackSpell == trigger_spell_id)
        {
            return false;
        }
 
        // Patch 2.2.0 Sword Specialization (Warrior, Rogue) extra attack can no longer proc additional extra attacks
        // 3.3.5 Sword Specialization (Warrior), Hack and Slash (Rogue)
        if (lastExtraAttackSpell == SPELL_SWORD_SPECIALIZATION || lastExtraAttackSpell == SPELL_HACK_AND_SLASH)
        {
            return false;
        }
    }
 
    // Custom requirements (not listed in procEx) Warning! damage dealing after this
    // Custom triggered spells
    switch (auraSpellInfo->Id)
    {
        // Deep Wounds
        case 12834:
        case 12849:
        case 12867:
            {
                if (GetTypeId() != TYPEID_PLAYER)
                    return false;
 
                if (procFlags & PROC_FLAG_DONE_OFFHAND_ATTACK)
                    basepoints0 = int32((GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE) + GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE)) / 2.0f);
                else
                    basepoints0 = int32((GetFloatValue(UNIT_FIELD_MAXDAMAGE) + GetFloatValue(UNIT_FIELD_MINDAMAGE)) / 2.0f);
                break;
            }
        // Persistent Shield (Scarab Brooch trinket)
        // This spell originally trigger 13567 - Dummy Trigger (vs dummy efect)
        case 26467:
            {
                basepoints0 = int32(CalculatePct(damage, 15));
                target = victim;
                trigger_spell_id = 26470;
                break;
            }
        // Unyielding Knights (item exploit 29108\29109)
        case 38164:
            {
                if (!victim || victim->GetEntry() != 19457)  // Proc only if your target is Grillok
                    return false;
                break;
            }
        // Deflection
        case 52420:
            {
                if (!HealthBelowPct(35))
                    return false;
                break;
            }
 
        // Cheat Death
        case 28845:
            {
                // When your health drops below 20%
                if (HealthBelowPctDamaged(20, damage) || HealthBelowPct(20))
                    return false;
                break;
            }
        // Deadly Swiftness (Rank 1)
        case 31255:
            {
                // whenever you deal damage to a target who is below 20% health.
                if (!victim || !victim->IsAlive() || victim->HealthAbovePct(20))
                    return false;
 
                target = this;
                trigger_spell_id = 22588;
                [[fallthrough]]; // TODO: Not sure whether the fallthrough was a mistake (forgetting a break) or intended. This should be double-checked.
            }
        // Bonus Healing (Crystal Spire of Karabor mace)
        case 40971:
            {
                // If your target is below $s1% health
                if (!victim || !victim->IsAlive() || victim->HealthAbovePct(triggerAmount))
                    return false;
                break;
            }
        // Rapid Recuperation
        case 53228:
        case 53232:
            {
                // This effect only from Rapid Fire (ability cast)
                if (!procSpell || !(procSpell->SpellFamilyFlags[0] & 0x20))
                    return false;
                break;
            }
        // Decimation
        case 63156:
        case 63158:
            // Can proc only if target has hp below 35%
            if (!victim || !victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, procSpell, this))
                return false;
            break;
        // Ulduar, Hodir, Toasty Fire
        case 62821:
            if (this->GetTypeId() != TYPEID_PLAYER) // spell has Attribute, but persistent area auras ignore it
                return false;
            break;
        case 15337: // Improved Spirit Tap (Rank 1)
        case 15338: // Improved Spirit Tap (Rank 2)
            {
                if (!procSpell)
                    return false;
 
                if (procSpell->SpellFamilyFlags[0] & 0x800000)
                    if ((procSpell->Id != 58381) || !roll_chance_i(50))
                        return false;
 
                target = victim;
                break;
            }
        // Professor Putricide - Ooze Spell Tank Protection
        case 71770:
            if (victim)
                victim->CastSpell(victim, trigger_spell_id, true);    // EffectImplicitTarget is self
            return true;
        case 45057: // Evasive Maneuvers (Commendation of Kael`thas trinket)
        case 71634: // Item - Icecrown 25 Normal Tank Trinket 1
        case 71640: // Item - Icecrown 25 Heroic Tank Trinket 1
        case 75475: // Item - Chamber of Aspects 25 Normal Tank Trinket
        case 75481: // Item - Chamber of Aspects 25 Heroic Tank Trinket
            {
                // Procs only if damage takes health below $s1%
                if (!HealthBelowPctDamaged(triggerAmount, damage))
                    return false;
                break;
            }
        default:
            break;
    }
 
    if (auraSpellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT)
    {
        // Xinef: keep this order, Aura 70656 has SpellIconID 85!
        // Item - Death Knight T10 Melee 4P Bonus
        if (auraSpellInfo->Id == 70656)
        {
            if (GetTypeId() != TYPEID_PLAYER || getClass() != CLASS_DEATH_KNIGHT)
                return false;
 
            for (uint8 i = 0; i < MAX_RUNES; ++i)
                if (ToPlayer()->GetRuneCooldown(i) == 0)
                    return false;
        }
        // Blade Barrier
        else if (auraSpellInfo->SpellIconID == 85)
        {
            Player* plr = ToPlayer();
            if (!plr || plr->getClass() != CLASS_DEATH_KNIGHT || !procSpell)
                return false;
 
            if (!plr->IsBaseRuneSlotsOnCooldown(RUNE_BLOOD))
                return false;
        }
        // Rime
        else if (auraSpellInfo->SpellIconID == 56)
        {
            if (GetTypeId() != TYPEID_PLAYER)
                return false;
 
            // Howling Blast
            ToPlayer()->RemoveCategoryCooldown(1248);
        }
    }
 
    // Custom basepoints/target for exist spell
    // dummy basepoints or other customs
    switch (trigger_spell_id)
    {
        // Auras which should proc on area aura source (caster in this case):
        // Turn the Tables
        case 52914:
        case 52915:
        case 52910:
        // Honor Among Thieves
        case 51699:
            {
                target = triggeredByAura->GetBase()->GetCaster();
                if (!target)
                    return false;
 
                if (Player* pTarget = target->ToPlayer())
                {
                    if (cooldown)
                    {
                        if (pTarget->HasSpellCooldown(trigger_spell_id) )
                            return false;
                        pTarget->AddSpellCooldown(trigger_spell_id, 0, cooldown);
                    }
 
                    Unit* cptarget = nullptr;
                    if (trigger_spell_id == 51699)
                    {
                        cptarget = pTarget->GetComboTarget();
                        if (!cptarget)
                        {
                            cptarget = pTarget->GetSelectedUnit();
                        }
                    }
                    else
                        cptarget = target;
 
                    if (cptarget)
                    {
                        target->CastSpell(cptarget, trigger_spell_id, true);
                        return true;
                    }
                }
                return false;
            }
        // Cast positive spell on enemy target
        case 7099:  // Curse of Mending
        case 39703: // Curse of Mending
        case 29494: // Temptation
        case 20233: // Improved Lay on Hands (cast on target)
            {
                target = victim;
                break;
            }
        // Ruby Drake, Evasive Aura
        case 50241:
            {
                if( GetAura(50240) )
                    return false;
 
                break;
            }
        // Combo points add triggers (need add combopoint only for main target, and after possible combopoints reset)
        case 15250: // Rogue Setup
            {
                // applied only for main target
                if (!victim || (GetTypeId() == TYPEID_PLAYER && victim != ToPlayer()->GetSelectedUnit()))
                    return false;
                break;                                   // continue normal case
            }
        // Finish movies that add combo
        case 14189: // Seal Fate (Netherblade set)
        case 14157: // Ruthlessness
            {
                victim = nullptr;
                // Need add combopoint AFTER finish movie (or they dropped in finish phase)
                break;
            }
        // Item - Druid T10 Balance 2P Bonus
        case 16870:
            {
                if (HasAura(70718))
                    CastSpell(this, 70721, true);
                RemoveAurasDueToSpell(trigger_spell_id);
                break;
            }
        // Shamanistic Rage triggered spell
        case 30824:
            {
                basepoints0 = int32(CalculatePct(GetTotalAttackPowerValue(BASE_ATTACK), triggerAmount));
                break;
            }
        // Enlightenment (trigger only from mana cost spells)
        case 35095:
            {
                if (!procSpell || procSpell->PowerType != POWER_MANA || (procSpell->ManaCost == 0 && procSpell->ManaCostPercentage == 0 && procSpell->ManaCostPerlevel == 0))
                    return false;
                break;
            }
        // Demonic Pact
        case 48090:
            {
                // Get talent aura from owner
                if (IsPet())
                    if (Unit* owner = GetOwner())
                    {
                        if (HasSpellCooldown(trigger_spell_id))
                            return false;
                        AddSpellCooldown(trigger_spell_id, 0, cooldown);
 
                        if (AuraEffect* aurEff = owner->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, 3220, 0))
                        {
                            int32 spellPower = owner->SpellBaseDamageBonusDone(SpellSchoolMask(SPELL_SCHOOL_MASK_MAGIC));
                            if (AuraEffect const* demonicAuraEffect = GetAuraEffect(trigger_spell_id, EFFECT_0))
                                spellPower -= demonicAuraEffect->GetAmount();
 
                            basepoints0 = int32((aurEff->GetAmount() * spellPower + 100.0f) / 100.0f);
                            CastCustomSpell(this, trigger_spell_id, &basepoints0, &basepoints0, nullptr, true, castItem, triggeredByAura);
                            return true;
                        }
                    }
                break;
            }
        case 46916:  // Slam! (Bloodsurge proc)
        case 52437:  // Sudden Death
            {
                // Item - Warrior T10 Melee 4P Bonus
                if (AuraEffect const* aurEff = GetAuraEffect(70847, 0))
                {
                    if (!roll_chance_i(aurEff->GetAmount()))
                    {
                        // Xinef: dont allow normal proc to override set one
                        if (GetAura((trigger_spell_id == 46916) ? 71072 : 71069))
                            return false;
                        // Xinef: just to be sure
                        RemoveAurasDueToSpell(70849);
                        break;
                    }
 
                    // Xinef: fully remove all auras and reapply once more
                    RemoveAurasDueToSpell(70849);
                    RemoveAurasDueToSpell(71072);
                    RemoveAurasDueToSpell(71069);
 
                    CastSpell(this, 70849, true, castItem, triggeredByAura); // Extra Charge!
                    if (trigger_spell_id == 46916)
                        CastSpell(this, 71072, true, castItem, triggeredByAura); // Slam GCD Reduced
                    else
                        CastSpell(this, 71069, true, castItem, triggeredByAura); // Execute GCD Reduced
                }
                break;
            }
        // Sword and Board
        case 50227:
            {
                // Remove cooldown on Shield Slam
                if (GetTypeId() == TYPEID_PLAYER)
                    ToPlayer()->RemoveCategoryCooldown(1209);
                break;
            }
        // Maelstrom Weapon
        case 53817:
            {
                // have rank dependent proc chance, ignore too often cases
                // PPM = 2.5 * (rank of talent),
                uint32 rank = auraSpellInfo->GetRank();
                // 5 rank -> 100% 4 rank -> 80% and etc from full rate
                if (!roll_chance_i(20 * rank))
                    return false;
 
                // Item - Shaman T10 Enhancement 4P Bonus
                if (AuraEffect const* aurEff = GetAuraEffect(70832, 0))
                    if (Aura const* maelstrom = GetAura(53817))
                        // xinef: we have 4 charges and all proc conditions are met - aura reaches 5 charges
                        if ((maelstrom->GetStackAmount() == 4) && roll_chance_i(aurEff->GetAmount()))
                            CastSpell(this, 70831, true, castItem, triggeredByAura);
 
                break;
            }
        // Astral Shift
        case 52179:
            {
                if (!procSpell || !(procEx & (PROC_EX_NORMAL_HIT | PROC_EX_CRITICAL_HIT)) || this == victim)
                    return false;
 
                // Need stun, fear or silence mechanic
                if (!(procSpell->GetAllEffectsMechanicMask() & ((1 << MECHANIC_SILENCE) | (1 << MECHANIC_STUN) | (1 << MECHANIC_FEAR))))
                    return false;
                break;
            }
        // Glyph of Death's Embrace
        case 58679:
            {
                // Proc only from healing part of Death Coil. Check is essential as all Death Coil spells have 0x2000 mask in SpellFamilyFlags
                if (!procSpell || !(procSpell->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT && procSpell->SpellFamilyFlags[0] == 0x80002000))
                    return false;
                break;
            }
        // Glyph of Death Grip
        case 58628:
            {
                // remove cooldown of Death Grip
                if (GetTypeId() == TYPEID_PLAYER)
                    ToPlayer()->RemoveSpellCooldown(49576, true);
                return true;
            }
        // Savage Defense
        case 62606:
            {
                basepoints0 = CalculatePct(triggerAmount, GetTotalAttackPowerValue(BASE_ATTACK));
                break;
            }
        // Body and Soul
        case 64128:
        case 65081:
            {
                // Proc only from PW:S cast
                if (!procSpell || !(procSpell->SpellFamilyFlags[0] & 0x00000001))
                    return false;
                break;
            }
        // Culling the Herd
        case 70893:
            {
                if (!procSpell)
                {
                    return false;
                }
                // check if we're doing a critical hit
                if (!(procSpell->SpellFamilyFlags[1] & 0x10000000) && (procEx != PROC_EX_CRITICAL_HIT))
                    return false;
                // check if we're procced by Claw, Bite or Smack (need to use the spell icon ID to detect it)
                if (!(procSpell->SpellIconID == 262 || procSpell->SpellIconID == 1680 || procSpell->SpellIconID == 473))
                    return false;
                break;
            }
        // Fingers of Frost, synchronise with Frostbite
        case 44544:
            {
                if (procPhase == PROC_SPELL_PHASE_HIT)
                {
                    // Find Frostbite
                    if (AuraEffect* aurEff = this->GetAuraEffect(SPELL_AURA_ADD_TARGET_TRIGGER, SPELLFAMILY_MAGE, 119, EFFECT_0))
                    {
                        if (!victim)
                            return false;
 
                        uint8 fofRank = sSpellMgr->GetSpellRank(triggeredByAura->GetId());
                        uint8 fbRank  = sSpellMgr->GetSpellRank(aurEff->GetId());
                        uint8 chance  = uint8(std::ceil(fofRank * fbRank * 16.6f));
 
                        if (roll_chance_i(chance))
                            CastSpell(victim, aurEff->GetSpellInfo()->Effects[EFFECT_0].TriggerSpell, true);
                    }
                }
                break;
            }
    }
 
    // try detect target manually if not set
    if (!target)
        target = !(procFlags & (PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS | PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS)) && triggerEntry->IsPositive() ? this : victim;
 
    if (cooldown)
    {
        if (HasSpellCooldown(triggerEntry->Id))
            return false;
 
        AddSpellCooldown(triggerEntry->Id, 0, cooldown);
    }
 
    if(basepoints0)
        CastCustomSpell(target, triggerEntry->Id, &basepoints0, nullptr, nullptr, true, castItem, triggeredByAura);
    else
        CastSpell(target, triggerEntry->Id, true, castItem, triggeredByAura);
 
    return true;
}

◆ HandleSafeUnitPointersOnDelete()

void Unit::HandleSafeUnitPointersOnDelete ( Unit * thisUnit )

static

Definition at line 4257 of file Unit.cpp.

{
    if (thisUnit->SafeUnitPointerSet.empty())
        return;
    for (std::set<SafeUnitPointer*>::iterator itr = thisUnit->SafeUnitPointerSet.begin(); itr != thisUnit->SafeUnitPointerSet.end(); ++itr)
        (*itr)->UnitDeleted();
 
    thisUnit->SafeUnitPointerSet.clear();
}

◆ HandleSpellClick()

bool Unit::HandleSpellClick	(	Unit *	clicker,
		int8	seatId = `-1`
	)

First check simple relations from clicker to clickee

Check database conditions

Definition at line 19566 of file Unit.cpp.

{
    Creature* creature = ToCreature();
    if (creature && creature->IsAIEnabled)
    {
        if (!creature->AI()->BeforeSpellClick(clicker))
        {
            return false;
        }
    }
 
    bool result = false;
    uint32 spellClickEntry = GetVehicleKit() ? GetVehicleKit()->GetCreatureEntry() : GetEntry();
    SpellClickInfoMapBounds clickPair = sObjectMgr->GetSpellClickInfoMapBounds(spellClickEntry);
    for (SpellClickInfoContainer::const_iterator itr = clickPair.first; itr != clickPair.second; ++itr)
    {
        if (!itr->second.IsFitToRequirements(clicker, this))
            continue;
 
        ConditionList conds = sConditionMgr->GetConditionsForSpellClickEvent(spellClickEntry, itr->second.spellId);
        ConditionSourceInfo info = ConditionSourceInfo(clicker, this);
        if (!sConditionMgr->IsObjectMeetToConditions(info, conds))
            continue;
 
        Unit* caster = (itr->second.castFlags & NPC_CLICK_CAST_CASTER_CLICKER) ? clicker : this;
        Unit* target = (itr->second.castFlags & NPC_CLICK_CAST_TARGET_CLICKER) ? clicker : this;
        ObjectGuid origCasterGUID = (itr->second.castFlags & NPC_CLICK_CAST_ORIG_CASTER_OWNER) ? GetOwnerGUID() : clicker->GetGUID();
 
        SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(itr->second.spellId);
 
        // xinef: dont allow players to enter vehicles on arena
        if (spellEntry->HasAura(SPELL_AURA_CONTROL_VEHICLE) && caster->GetTypeId() == TYPEID_PLAYER && caster->FindMap() && caster->FindMap()->IsBattleArena())
            continue;
 
        if (seatId > -1)
        {
            uint8 i = 0;
            bool valid = false;
            while (i < MAX_SPELL_EFFECTS)
            {
                if (spellEntry->Effects[i].ApplyAuraName == SPELL_AURA_CONTROL_VEHICLE)
                {
                    valid = true;
                    break;
                }
                ++i;
            }
 
            if (!valid)
            {
                LOG_ERROR("sql.sql", "Spell {} specified in npc_spellclick_spells is not a valid vehicle enter aura!", itr->second.spellId);
                continue;
            }
 
            if (IsInMap(caster))
                caster->CastCustomSpell(itr->second.spellId, SpellValueMod(SPELLVALUE_BASE_POINT0 + i), seatId + 1, target, GetVehicleKit() ? TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE : TRIGGERED_NONE, nullptr, nullptr, origCasterGUID);
            else    // This can happen during Player::_LoadAuras
            {
                int32 bp0[MAX_SPELL_EFFECTS];
                for (uint32 j = 0; j < MAX_SPELL_EFFECTS; ++j)
                    bp0[j] = spellEntry->Effects[j].BasePoints;
 
                bp0[i] = seatId;
                Aura::TryRefreshStackOrCreate(spellEntry, MAX_EFFECT_MASK, this, clicker, bp0, nullptr, origCasterGUID);
            }
        }
        else
        {
            if (IsInMap(caster))
                caster->CastSpell(target, spellEntry, GetVehicleKit() ? TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE : TRIGGERED_NONE, nullptr, nullptr, origCasterGUID);
            else
                Aura::TryRefreshStackOrCreate(spellEntry, MAX_EFFECT_MASK, this, clicker, nullptr, nullptr, origCasterGUID);
        }
 
        result = true;
    }
 
    if (creature && creature->IsAIEnabled)
        creature->AI()->OnSpellClick(clicker, result);
 
    return result;
}

◆ HandleStatModifier()

bool Unit::HandleStatModifier	(	UnitMods	unitMod,
		UnitModifierType	modifierType,
		float	amount,
		bool	apply
	)

Definition at line 15060 of file Unit.cpp.

{
    if (unitMod >= UNIT_MOD_END || modifierType >= MODIFIER_TYPE_END)
    {
        LOG_ERROR("entities.unit", "ERROR in HandleStatModifier(): non-existing UnitMods or wrong UnitModifierType!");
        return false;
    }
 
    switch (modifierType)
    {
        case BASE_VALUE:
        case TOTAL_VALUE:
            m_auraModifiersGroup[unitMod][modifierType] += apply ? amount : -amount;
            break;
        case BASE_PCT:
        case TOTAL_PCT:
            ApplyPercentModFloatVar(m_auraModifiersGroup[unitMod][modifierType], amount, apply);
            break;
        default:
            break;
    }
 
    if (!CanModifyStats())
        return false;
 
    switch (unitMod)
    {
        case UNIT_MOD_STAT_STRENGTH:
        case UNIT_MOD_STAT_AGILITY:
        case UNIT_MOD_STAT_STAMINA:
        case UNIT_MOD_STAT_INTELLECT:
        case UNIT_MOD_STAT_SPIRIT:
            UpdateStats(GetStatByAuraGroup(unitMod));
            break;
 
        case UNIT_MOD_ARMOR:
            UpdateArmor();
            break;
        case UNIT_MOD_HEALTH:
            UpdateMaxHealth();
            break;
 
        case UNIT_MOD_MANA:
        case UNIT_MOD_RAGE:
        case UNIT_MOD_FOCUS:
        case UNIT_MOD_ENERGY:
        case UNIT_MOD_HAPPINESS:
        case UNIT_MOD_RUNE:
        case UNIT_MOD_RUNIC_POWER:
            UpdateMaxPower(GetPowerTypeByAuraGroup(unitMod));
            break;
 
        case UNIT_MOD_RESISTANCE_HOLY:
        case UNIT_MOD_RESISTANCE_FIRE:
        case UNIT_MOD_RESISTANCE_NATURE:
        case UNIT_MOD_RESISTANCE_FROST:
        case UNIT_MOD_RESISTANCE_SHADOW:
        case UNIT_MOD_RESISTANCE_ARCANE:
            UpdateResistances(GetSpellSchoolByAuraGroup(unitMod));
            break;
 
        case UNIT_MOD_ATTACK_POWER:
            UpdateAttackPowerAndDamage();
            break;
        case UNIT_MOD_ATTACK_POWER_RANGED:
            UpdateAttackPowerAndDamage(true);
            break;
 
        case UNIT_MOD_DAMAGE_MAINHAND:
            UpdateDamagePhysical(BASE_ATTACK);
            break;
        case UNIT_MOD_DAMAGE_OFFHAND:
            UpdateDamagePhysical(OFF_ATTACK);
            break;
        case UNIT_MOD_DAMAGE_RANGED:
            UpdateDamagePhysical(RANGED_ATTACK);
            break;
 
        default:
            break;
    }
 
    return true;
}

◆ HasAura()

bool Unit::HasAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		ObjectGuid	itemCasterGUID = `ObjectGuid::Empty`,
		uint8	reqEffMask = `0`
	)		const

Definition at line 5598 of file Unit.cpp.

{
    if (GetAuraApplication(spellId, casterGUID, itemCasterGUID, reqEffMask))
        return true;
    return false;
}

◆ HasAuraEffect()

bool Unit::HasAuraEffect	(	uint32	spellId,
		uint8	effIndex,
		ObjectGuid	caster = `ObjectGuid::Empty`
	)		const

Definition at line 5568 of file Unit.cpp.

{
    AuraApplicationMapBounds range = m_appliedAuras.equal_range(spellId);
    for (AuraApplicationMap::const_iterator itr = range.first; itr != range.second; ++itr)
    {
        if (itr->second->HasEffect(effIndex)
                && (!caster || itr->second->GetBase()->GetCasterGUID() == caster))
        {
            return true;
        }
    }
    return false;
}

◆ HasAuraState()

bool Unit::HasAuraState	(	AuraStateType	flag,
		SpellInfo const *	spellProto = `nullptr`,
		Unit const *	Caster = `nullptr`
	)		const

Definition at line 10495 of file Unit.cpp.

{
    if (Caster)
    {
        if (spellProto)
        {
            AuraEffectList const& stateAuras = Caster->GetAuraEffectsByType(SPELL_AURA_ABILITY_IGNORE_AURASTATE);
            for (AuraEffectList::const_iterator j = stateAuras.begin(); j != stateAuras.end(); ++j)
                if ((*j)->IsAffectedOnSpell(spellProto))
                    return true;
        }
        // Check per caster aura state
        // If aura with aurastate by caster not found return false
        if ((1 << (flag - 1)) & PER_CASTER_AURA_STATE_MASK)
        {
            AuraStateAurasMapBounds range = m_auraStateAuras.equal_range(flag);
            for (AuraStateAurasMap::const_iterator itr = range.first; itr != range.second; ++itr)
                if (itr->second->GetBase()->GetCasterGUID() == Caster->GetGUID())
                    return true;
            return false;
        }
    }
 
    return HasFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1));
}

◆ HasAuraType()

bool Unit::HasAuraType ( AuraType auraType ) const

Definition at line 5605 of file Unit.cpp.

{
    return (!m_modAuras[auraType].empty());
}

◆ HasAuraTypeWithAffectMask()

bool Unit::HasAuraTypeWithAffectMask	(	AuraType	auratype,
		SpellInfo const *	affectedSpell
	)		const

Definition at line 5638 of file Unit.cpp.

{
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if ((*i)->IsAffectedOnSpell(affectedSpell))
            return true;
    return false;
}

◆ HasAuraTypeWithCaster()

bool Unit::HasAuraTypeWithCaster	(	AuraType	auratype,
		ObjectGuid	caster
	)		const

Definition at line 5610 of file Unit.cpp.

{
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if (caster == (*i)->GetCasterGUID())
            return true;
    return false;
}

◆ HasAuraTypeWithFamilyFlags()

bool Unit::HasAuraTypeWithFamilyFlags	(	AuraType	auraType,
		uint32	familyName,
		uint32	familyFlags
	)		const

Definition at line 769 of file Unit.cpp.

{
    if (!HasAuraType(auraType))
        return false;
    AuraEffectList const& auras = GetAuraEffectsByType(auraType);
    for (AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
        if (SpellInfo const* iterSpellProto = (*itr)->GetSpellInfo())
            if (iterSpellProto->SpellFamilyName == familyName && iterSpellProto->SpellFamilyFlags[0] & familyFlags)
                return true;
    return false;
}

◆ HasAuraTypeWithMiscvalue()

bool Unit::HasAuraTypeWithMiscvalue	(	AuraType	auratype,
		int32	miscvalue
	)		const

Definition at line 5629 of file Unit.cpp.

{
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if (miscvalue == (*i)->GetMiscValue())
            return true;
    return false;
}

◆ HasAuraTypeWithTriggerSpell()

bool Unit::HasAuraTypeWithTriggerSpell	(	AuraType	auratype,
		uint32	triggerSpell
	)		const

Definition at line 5656 of file Unit.cpp.

{
    for (AuraEffect const* aura : GetAuraEffectsByType(auratype))
    {
        if (aura->GetSpellInfo()->Effects[aura->GetEffIndex()].TriggerSpell == triggerSpell)
        {
            return true;
        }
    }
 
    return false;
}

◆ HasAuraTypeWithValue()

bool Unit::HasAuraTypeWithValue	(	AuraType	auratype,
		int32	value
	)		const

Definition at line 5647 of file Unit.cpp.

{
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if (value == (*i)->GetAmount())
            return true;
    return false;
}

◆ HasAuraWithMechanic()

bool Unit::HasAuraWithMechanic ( uint32 mechanicMask ) const

Definition at line 5692 of file Unit.cpp.

{
    for (AuraApplicationMap::const_iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end(); ++iter)
    {
        SpellInfo const* spellInfo  = iter->second->GetBase()->GetSpellInfo();
        if (spellInfo->Mechanic && (mechanicMask & (1 << spellInfo->Mechanic)))
            return true;
 
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            if (iter->second->HasEffect(i) && spellInfo->Effects[i].Effect && spellInfo->Effects[i].Mechanic)
                if (mechanicMask & (1 << spellInfo->Effects[i].Mechanic))
                    return true;
    }
 
    return false;
}

◆ HasBreakableByDamageAuraType()

bool Unit::HasBreakableByDamageAuraType	(	AuraType	type,
		uint32	excludeAura = `0`
	)		const

Definition at line 781 of file Unit.cpp.

{
    AuraEffectList const& auras = GetAuraEffectsByType(type);
    for (AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
        if ((!excludeAura || excludeAura != (*itr)->GetSpellInfo()->Id) && //Avoid self interrupt of channeled Crowd Control spells like Seduction
                ((*itr)->GetSpellInfo()->AuraInterruptFlags & AURA_INTERRUPT_FLAG_TAKE_DAMAGE))
            return true;
    return false;
}

◆ HasBreakableByDamageCrowdControlAura()

bool Unit::HasBreakableByDamageCrowdControlAura ( Unit * excludeCasterChannel = nullptr ) const

Definition at line 791 of file Unit.cpp.

{
    uint32 excludeAura = 0;
    if (Spell* currentChanneledSpell = excludeCasterChannel ? excludeCasterChannel->GetCurrentSpell(CURRENT_CHANNELED_SPELL) : nullptr)
        excludeAura = currentChanneledSpell->GetSpellInfo()->Id; //Avoid self interrupt of channeled Crowd Control spells like Seduction
 
    return (   HasBreakableByDamageAuraType(SPELL_AURA_MOD_CONFUSE, excludeAura)
               || HasBreakableByDamageAuraType(SPELL_AURA_MOD_FEAR, excludeAura)
               || HasBreakableByDamageAuraType(SPELL_AURA_MOD_STUN, excludeAura)
               || HasBreakableByDamageAuraType(SPELL_AURA_MOD_ROOT, excludeAura)
               || HasBreakableByDamageAuraType(SPELL_AURA_TRANSFORM, excludeAura));
}

◆ HasExtraUnitMovementFlag()

uint16 Unit::HasExtraUnitMovementFlag ( uint16 f ) const

inline

Definition at line 2275 of file Unit.h.

2275{ return m_movementInfo.flags2 & f; }

◆ HasInvisibilityAura()

bool Unit::HasInvisibilityAura ( ) const

inline

Definition at line 1704 of file Unit.h.

1704{ return HasAuraType(SPELL_AURA_MOD_INVISIBILITY); }

SPELL_AURA_MOD_INVISIBILITY

@ SPELL_AURA_MOD_INVISIBILITY

Definition: SpellAuraDefines.h:81

◆ HasNegativeAuraWithAttribute()

bool Unit::HasNegativeAuraWithAttribute	(	uint32	flag,
		ObjectGuid	guid = `ObjectGuid::Empty`
	)

Definition at line 5681 of file Unit.cpp.

{
    for (AuraApplicationMap::const_iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end(); ++iter)
    {
        Aura const* aura = iter->second->GetBase();
        if (!iter->second->IsPositive() && aura->GetSpellInfo()->Attributes & flag && (!guid || aura->GetCasterGUID() == guid))
            return true;
    }
    return false;
}

◆ HasNegativeAuraWithInterruptFlag()

bool Unit::HasNegativeAuraWithInterruptFlag	(	uint32	flag,
		ObjectGuid	guid = `ObjectGuid::Empty`
	)

Definition at line 5669 of file Unit.cpp.

{
    if (!(m_interruptMask & flag))
        return false;
    for (AuraApplicationList::iterator iter = m_interruptableAuras.begin(); iter != m_interruptableAuras.end(); ++iter)
    {
        if (!(*iter)->IsPositive() && (*iter)->GetBase()->GetSpellInfo()->AuraInterruptFlags & flag && (!guid || (*iter)->GetBase()->GetCasterGUID() == guid))
            return true;
    }
    return false;
}

◆ HasNpcFlag()

bool Unit::HasNpcFlag ( NPCFlags flags ) const

inline

Definition at line 1643 of file Unit.h.

1643{ return HasFlag(UNIT_NPC_FLAGS, flags) != 0; }

◆ HasSharedVision()

bool Unit::HasSharedVision ( ) const

inline

Definition at line 1889 of file Unit.h.

1889{ return !m_sharedVision.empty(); }

◆ HasSpell()

virtual bool Unit::HasSpell ( uint32 ) const

inlinevirtual

Reimplemented in Pet, Player, and Creature.

Definition at line 1699 of file Unit.h.

1699{ return false; }

◆ HasSpellCooldown()

virtual bool Unit::HasSpellCooldown ( uint32 ) const

inlinevirtual

Reimplemented in Creature, and Player.

Definition at line 2413 of file Unit.h.

2413{ return false; }

◆ HasSpellItemCooldown()

virtual bool Unit::HasSpellItemCooldown	(	uint32	,
		uint32
	)		const

inlinevirtual

Reimplemented in Player.

Definition at line 2414 of file Unit.h.

2414{ return false; }

◆ HasStealthAura()

bool Unit::HasStealthAura ( ) const

inline

Definition at line 1703 of file Unit.h.

1703{ return HasAuraType(SPELL_AURA_MOD_STEALTH); }

◆ HasUnitFlag()

bool Unit::HasUnitFlag ( UnitFlags flags ) const

inline

Definition at line 1478 of file Unit.h.

1478{ return HasFlag(UNIT_FIELD_FLAGS, flags); }

◆ HasUnitFlag2()

bool Unit::HasUnitFlag2 ( UnitFlags2 flags ) const

inline

Definition at line 1484 of file Unit.h.

1484{ return HasFlag(UNIT_FIELD_FLAGS_2, flags); }

◆ HasUnitMovementFlag()

bool Unit::HasUnitMovementFlag ( uint32 f ) const

inline

Definition at line 2269 of file Unit.h.

2269{ return (m_movementInfo.flags & f) == f; }

◆ HasUnitState()

bool Unit::HasUnitState ( const uint32 f ) const

inline

Definition at line 1398 of file Unit.h.

1398{ return (m_state & f); }

◆ HasUnitTypeMask()

uint32 Unit::HasUnitTypeMask ( uint32 mask ) const

inline

Definition at line 1407 of file Unit.h.

1407{ return mask & m_unitTypeMask; }

◆ HasVisibleAuraType()

bool Unit::HasVisibleAuraType ( AuraType auraType ) const

Definition at line 5619 of file Unit.cpp.

{
    AuraEffectList const& mAuraList = GetAuraEffectsByType(auraType);
    for (AuraEffectList::const_iterator i = mAuraList.begin(); i != mAuraList.end(); ++i)
        if( (*i)->GetBase()->CanBeSentToClient() )
            return true;
 
    return false;
}

◆ haveOffhandWeapon()

bool Unit::haveOffhandWeapon ( ) const

Definition at line 539 of file Unit.cpp.

{
    if (Player const* player = ToPlayer())
        return player->GetWeaponForAttack(OFF_ATTACK, true);
 
    return CanDualWield();
}

◆ HealBySpell()

int32 Unit::HealBySpell	(	HealInfo &	healInfo,
		bool	critical = `false`
	)

Definition at line 11190 of file Unit.cpp.

{
    uint32 heal = healInfo.GetHeal();
    sScriptMgr->ModifyHealReceived(this, healInfo.GetTarget(), heal, healInfo.GetSpellInfo());
    healInfo.SetHeal(heal);
 
    // calculate heal absorb and reduce healing
    CalcHealAbsorb(healInfo);
 
    int32 gain = Unit::DealHeal(healInfo.GetHealer(), healInfo.GetTarget(), healInfo.GetHeal());
    SendHealSpellLog(healInfo.GetTarget(), healInfo.GetSpellInfo()->Id, healInfo.GetHeal(), uint32(healInfo.GetHeal() - gain), healInfo.GetAbsorb(), critical);
    return gain;
}

◆ HealthAbovePct()

bool Unit::HealthAbovePct ( int32 pct ) const

inline

Definition at line 1444 of file Unit.h.

1444{ return GetHealth() > CountPctFromMaxHealth(pct); }

◆ HealthAbovePctHealed()

bool Unit::HealthAbovePctHealed	(	int32	pct,
		uint32	heal
	)		const

inline

Definition at line 1445 of file Unit.h.

1445{ return uint64(GetHealth()) + uint64(heal) > CountPctFromMaxHealth(pct); }

◆ HealthBelowPct()

bool Unit::HealthBelowPct ( int32 pct ) const

inline

Definition at line 1442 of file Unit.h.

1442{ return GetHealth() < CountPctFromMaxHealth(pct); }

◆ HealthBelowPctDamaged()

bool Unit::HealthBelowPctDamaged	(	int32	pct,
		uint32	damage
	)		const

inline

Definition at line 1443 of file Unit.h.

1443{ return int64(GetHealth()) - int64(damage) < int64(CountPctFromMaxHealth(pct)); }

int64

std::int64_t int64

Definition: Define.h:103

◆ IncrDiminishing()

void Unit::IncrDiminishing ( DiminishingGroup group )

Definition at line 14890 of file Unit.cpp.

{
    // Checking for existing in the table
    for (Diminishing::iterator i = m_Diminishing.begin(); i != m_Diminishing.end(); ++i)
    {
        if (i->DRGroup != group)
            continue;
        if (int32(i->hitCount) < GetDiminishingReturnsMaxLevel(group))
            i->hitCount += 1;
        return;
    }
    m_Diminishing.push_back(DiminishingReturn(group, GameTime::GetGameTimeMS().count(), DIMINISHING_LEVEL_2));
}

◆ InitCharmInfo()

CharmInfo * Unit::InitCharmInfo ( )

Definition at line 15649 of file Unit.cpp.

{
    if (!m_charmInfo)
        m_charmInfo = new CharmInfo(this);
 
    return m_charmInfo;
}

◆ InitStatBuffMods()

void Unit::InitStatBuffMods ( )

inline

Definition at line 2026 of file Unit.h.

    {
        for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i) SetFloatValue(static_cast<uint16>(UNIT_FIELD_POSSTAT0) +  i, 0);
        for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i) SetFloatValue(static_cast<uint16>(UNIT_FIELD_NEGSTAT0) +  i, 0);
    }

◆ InitTamedPet()

bool Unit::InitTamedPet	(	Pet *	pet,
		uint8	level,
		uint32	spell_id
	)

Definition at line 17445 of file Unit.cpp.

{
    Player* player = ToPlayer();
    PetStable& petStable = player->GetOrInitPetStable();
    if (petStable.CurrentPet || petStable.GetUnslottedHunterPet())
        return false;
 
    pet->SetCreatorGUID(GetGUID());
    pet->SetFaction(GetFaction());
    pet->SetUInt32Value(UNIT_CREATED_BY_SPELL, spell_id);
 
    if (GetTypeId() == TYPEID_PLAYER)
        pet->ReplaceAllUnitFlags(UNIT_FLAG_PLAYER_CONTROLLED);
 
    if (!pet->InitStatsForLevel(level))
    {
        LOG_ERROR("entities.unit", "Pet::InitStatsForLevel() failed for creature (Entry: {})!", pet->GetEntry());
        return false;
    }
 
    pet->GetCharmInfo()->SetPetNumber(sObjectMgr->GeneratePetNumber(), true);
    // this enables pet details window (Shift+P)
    pet->InitPetCreateSpells();
    pet->SetFullHealth();
    pet->FillPetInfo(&petStable.CurrentPet.emplace());
    return true;
}

◆ InterruptNonMeleeSpells()

void Unit::InterruptNonMeleeSpells	(	bool	withDelayed,
		uint32	spellid = `0`,
		bool	withInstant = `true`,
		bool	bySelf = `false`
	)

Definition at line 4057 of file Unit.cpp.

{
    // generic spells are interrupted if they are not finished or delayed
    if (m_currentSpells[CURRENT_GENERIC_SPELL] && (!spell_id || m_currentSpells[CURRENT_GENERIC_SPELL]->m_spellInfo->Id == spell_id))
        InterruptSpell(CURRENT_GENERIC_SPELL, withDelayed, withInstant, bySelf);
 
    // autorepeat spells are interrupted if they are not finished or delayed
    if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL] && (!spell_id || m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id == spell_id))
        InterruptSpell(CURRENT_AUTOREPEAT_SPELL, withDelayed, withInstant, bySelf);
 
    // channeled spells are interrupted if they are not finished, even if they are delayed
    if (m_currentSpells[CURRENT_CHANNELED_SPELL] && (!spell_id || m_currentSpells[CURRENT_CHANNELED_SPELL]->m_spellInfo->Id == spell_id))
        InterruptSpell(CURRENT_CHANNELED_SPELL, true, true, bySelf);
}

◆ InterruptSpell()

void Unit::InterruptSpell	(	CurrentSpellTypes	spellType,
		bool	withDelayed = `true`,
		bool	withInstant = `true`,
		bool	bySelf = `false`
	)

Definition at line 3990 of file Unit.cpp.

{
    //LOG_DEBUG("entities.unit", "Interrupt spell for unit {}.", GetEntry());
    Spell* spell = m_currentSpells[spellType];
    if (spell
            && (withDelayed || spell->getState() != SPELL_STATE_DELAYED)
            && (withInstant || spell->GetCastTime() > 0 || spell->getState() == SPELL_STATE_CASTING)) // xinef: or spell is in casting state (channeled spells only)
    {
        // for example, do not let self-stun aura interrupt itself
        if (!spell->IsInterruptable())
            return;
 
        // send autorepeat cancel message for autorepeat spells
        if (spellType == CURRENT_AUTOREPEAT_SPELL)
            if (GetTypeId() == TYPEID_PLAYER)
                ToPlayer()->SendAutoRepeatCancel(this);
 
        if (spell->getState() != SPELL_STATE_FINISHED)
            spell->cancel(bySelf);
 
        m_currentSpells[spellType] = nullptr;
        spell->SetReferencedFromCurrent(false);
    }
}

◆ IsAlive()

bool Unit::IsAlive ( ) const

inline

Definition at line 1805 of file Unit.h.

1805{ return (m_deathState == ALIVE); };

◆ IsAlwaysDetectableFor()

bool Unit::IsAlwaysDetectableFor ( WorldObject const * seer ) const

overrideprotectedvirtual

Reimplemented from WorldObject.

Definition at line 14099 of file Unit.cpp.

{
    if (WorldObject::IsAlwaysDetectableFor(seer))
        return true;
 
    if (HasAuraTypeWithCaster(SPELL_AURA_MOD_STALKED, seer->GetGUID()))
        return true;
 
    if (Player* ownerPlayer = GetSpellModOwner())
        if (Player const* seerPlayer = seer->ToPlayer())
        {
            if (ownerPlayer->IsGroupVisibleFor(seerPlayer))
                return true;
        }
 
    return false;
}

◆ IsAlwaysVisibleFor()

bool Unit::IsAlwaysVisibleFor ( WorldObject const * seer ) const

overrideprotectedvirtual

Reimplemented from WorldObject.

Definition at line 14080 of file Unit.cpp.

{
    if (WorldObject::IsAlwaysVisibleFor(seer))
        return true;
 
    // Always seen by owner
    if (ObjectGuid guid = GetCharmerOrOwnerGUID())
        if (seer->GetGUID() == guid)
            return true;
 
    if (Player const* seerPlayer = seer->ToPlayer())
        if (Unit* owner =  GetOwner())
            if (Player* ownerPlayer = owner->ToPlayer())
                if (ownerPlayer->IsGroupVisibleFor(seerPlayer))
                    return true;
 
    return false;
}

◆ IsArmorer()

bool Unit::IsArmorer ( ) const

inline

Definition at line 1661 of file Unit.h.

1661{ return HasNpcFlag(UNIT_NPC_FLAG_REPAIR); }

UNIT_NPC_FLAG_REPAIR

@ UNIT_NPC_FLAG_REPAIR

Definition: Unit.h:528

Unit::HasNpcFlag

bool HasNpcFlag(NPCFlags flags) const

Definition: Unit.h:1643

◆ isAttackingPlayer()

bool Unit::isAttackingPlayer ( ) const

Definition at line 10413 of file Unit.cpp.

{
    if (HasUnitState(UNIT_STATE_ATTACK_PLAYER))
        return true;
 
    if (!m_Controlled.empty())
        for (ControlSet::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
            if ((*itr)->isAttackingPlayer())
                return true;
 
    for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
        if (m_SummonSlot[i])
            if (Creature* summon = GetMap()->GetCreature(m_SummonSlot[i]))
                if (summon->isAttackingPlayer())
                    return true;
 
    return false;
}

◆ isAttackReady()

bool Unit::isAttackReady ( WeaponAttackType type = BASE_ATTACK ) const

inline

Definition at line 1343 of file Unit.h.

1343{ return m_attackTimer[type] <= 0; }

◆ IsAuctioner()

bool Unit::IsAuctioner ( ) const

inline

Definition at line 1660 of file Unit.h.

1660{ return HasNpcFlag(UNIT_NPC_FLAG_AUCTIONEER); }

UNIT_NPC_FLAG_AUCTIONEER

@ UNIT_NPC_FLAG_AUCTIONEER

Definition: Unit.h:537

◆ IsBanker()

bool Unit::IsBanker ( ) const

inline

Definition at line 1655 of file Unit.h.

1655{ return HasNpcFlag(UNIT_NPC_FLAG_BANKER); }

UNIT_NPC_FLAG_BANKER

@ UNIT_NPC_FLAG_BANKER

Definition: Unit.h:533

◆ IsBattleMaster()

bool Unit::IsBattleMaster ( ) const

inline

Definition at line 1654 of file Unit.h.

1654{ return HasNpcFlag(UNIT_NPC_FLAG_BATTLEMASTER); }

UNIT_NPC_FLAG_BATTLEMASTER

@ UNIT_NPC_FLAG_BATTLEMASTER

Definition: Unit.h:536

◆ isBeingLoaded()

virtual bool Unit::isBeingLoaded ( ) const

inlinevirtual

Reimplemented in Pet, and Player.

Definition at line 2390 of file Unit.h.

2390{ return false;}

◆ isBlockCritical()

bool Unit::isBlockCritical ( )

Definition at line 3068 of file Unit.cpp.

{
    if (roll_chance_i(GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_CRIT_CHANCE)))
        return true;
    return false;
}

◆ IsCharmed()

bool Unit::IsCharmed ( ) const

inline

Definition at line 1868 of file Unit.h.

1868{ return GetCharmerGUID(); }

◆ IsCharmedOwnedByPlayerOrPlayer()

bool Unit::IsCharmedOwnedByPlayerOrPlayer ( ) const

inline

Definition at line 1835 of file Unit.h.

1835{ return GetCharmerOrOwnerOrOwnGUID().IsPlayer(); }

Unit::GetCharmerOrOwnerOrOwnGUID

ObjectGuid GetCharmerOrOwnerOrOwnGUID() const

Definition: Unit.h:1828

◆ IsContestedGuard()

bool Unit::IsContestedGuard ( ) const

inline

Definition at line 1507 of file Unit.h.

    {
        if (FactionTemplateEntry const* entry = GetFactionTemplateEntry())
            return entry->IsContestedGuardFaction();
 
        return false;
    }

◆ IsControllableGuardian()

bool Unit::IsControllableGuardian ( ) const

inline

Definition at line 1412 of file Unit.h.

1412{ return m_unitTypeMask & UNIT_MASK_CONTROLABLE_GUARDIAN; }

◆ IsControlledByPlayer()

bool Unit::IsControlledByPlayer ( ) const

inline

Definition at line 1825 of file Unit.h.

1825{ return m_ControlledByPlayer; }

◆ IsCreatedByPlayer()

bool Unit::IsCreatedByPlayer ( ) const

inline

Definition at line 1826 of file Unit.h.

1826{ return m_CreatedByPlayer; }

◆ IsCritter()

bool Unit::IsCritter ( ) const

inline

Definition at line 1671 of file Unit.h.

1671{ return GetCreatureType() == CREATURE_TYPE_CRITTER; }

CREATURE_TYPE_CRITTER

@ CREATURE_TYPE_CRITTER

Definition: SharedDefines.h:2607

◆ IsDamageReducedByArmor()

bool Unit::IsDamageReducedByArmor	(	SpellSchoolMask	damageSchoolMask,
		SpellInfo const *	spellInfo = `nullptr`,
		uint8	effIndex = `MAX_SPELL_EFFECTS`
	)

static

Definition at line 1966 of file Unit.cpp.

{
    // only physical spells damage gets reduced by armor
    if ((schoolMask & SPELL_SCHOOL_MASK_NORMAL) == 0)
        return false;
    if (spellInfo)
    {
        // there are spells with no specific attribute but they have "ignores armor" in tooltip
        if (spellInfo->HasAttribute(SPELL_ATTR0_CU_IGNORE_ARMOR))
            return false;
 
        // bleeding effects are not reduced by armor
        if (effIndex != MAX_SPELL_EFFECTS)
        {
            if (spellInfo->Effects[effIndex].ApplyAuraName == SPELL_AURA_PERIODIC_DAMAGE ||
                    spellInfo->Effects[effIndex].Effect == SPELL_EFFECT_SCHOOL_DAMAGE)
                if (spellInfo->GetEffectMechanicMask(effIndex) & (1 << MECHANIC_BLEED))
                    return false;
        }
    }
    return true;
}

◆ isDead()

bool Unit::isDead ( ) const

inline

Definition at line 1807 of file Unit.h.

1807{ return (m_deathState == DEAD || m_deathState == CORPSE); };

CORPSE

@ CORPSE

Definition: Unit.h:318

DEAD

@ DEAD

Definition: Unit.h:319

◆ IsDuringRemoveFromWorld()

bool Unit::IsDuringRemoveFromWorld ( ) const

inline

Definition at line 2391 of file Unit.h.

2391{return m_duringRemoveFromWorld;}

◆ isDying()

bool Unit::isDying ( ) const

inline

Definition at line 1806 of file Unit.h.

1806{ return (m_deathState == JUST_DIED); };

◆ IsEngaged()

bool Unit::IsEngaged ( ) const

inline

Definition at line 1682 of file Unit.h.

1682{ return IsInCombat(); }

Unit::IsInCombat

bool IsInCombat() const

Definition: Unit.h:1685

◆ IsEngagedBy()

bool Unit::IsEngagedBy ( Unit const * who ) const

inline

Definition at line 1683 of file Unit.h.

1683{ return IsInCombatWith(who); }

◆ IsFalling()

bool Unit::IsFalling ( ) const

Definition at line 19962 of file Unit.cpp.

{
    return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_FALLING | MOVEMENTFLAG_FALLING_FAR) || movespline->isFalling();
}

◆ isFeared()

bool Unit::isFeared ( ) const

inline

Definition at line 1705 of file Unit.h.

1705{ return HasAuraType(SPELL_AURA_MOD_FEAR); }

◆ IsFFAPvP()

bool Unit::IsFFAPvP ( ) const

inline

Definition at line 1516 of file Unit.h.

1516{ return HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP); }

UNIT_BYTE2_FLAG_FFA_PVP

@ UNIT_BYTE2_FLAG_FFA_PVP

Definition: Unit.h:138

◆ IsFlying()

bool Unit::IsFlying ( ) const

inline

Definition at line 2380 of file Unit.h.

2380{ return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_FLYING | MOVEMENTFLAG_DISABLE_GRAVITY); }

MOVEMENTFLAG_DISABLE_GRAVITY

@ MOVEMENTFLAG_DISABLE_GRAVITY

Definition: Unit.h:562

◆ IsFriendlyTo()

bool Unit::IsFriendlyTo ( Unit const * unit ) const

Definition at line 10202 of file Unit.cpp.

{
    return GetReactionTo(unit) >= REP_FRIENDLY;
}

◆ isFrozen()

bool Unit::isFrozen ( ) const

Definition at line 15927 of file Unit.cpp.

{
    return HasAuraState(AURA_STATE_FROZEN);
}

◆ IsFullHealth()

bool Unit::IsFullHealth ( ) const

inline

Definition at line 1441 of file Unit.h.

1441{ return GetHealth() == GetMaxHealth(); }

◆ IsGossip()

bool Unit::IsGossip ( ) const

inline

Definition at line 1651 of file Unit.h.

1651{ return HasNpcFlag(UNIT_NPC_FLAG_GOSSIP); }

◆ IsGuardian()

bool Unit::IsGuardian ( ) const

inline

Definition at line 1411 of file Unit.h.

1411{ return m_unitTypeMask & UNIT_MASK_GUARDIAN; }

◆ IsGuildMaster()

bool Unit::IsGuildMaster ( ) const

inline

Definition at line 1653 of file Unit.h.

1653{ return HasNpcFlag(UNIT_NPC_FLAG_PETITIONER); }

UNIT_NPC_FLAG_PETITIONER

@ UNIT_NPC_FLAG_PETITIONER

Definition: Unit.h:534

◆ IsHostileTo()

bool Unit::IsHostileTo ( Unit const * unit ) const

Definition at line 10197 of file Unit.cpp.

{
    return GetReactionTo(unit) <= REP_HOSTILE;
}

◆ IsHostileToPlayers()

bool Unit::IsHostileToPlayers ( ) const

Definition at line 10207 of file Unit.cpp.

{
    FactionTemplateEntry const* my_faction = GetFactionTemplateEntry();
    if (!my_faction || !my_faction->faction)
        return false;
 
    FactionEntry const* raw_faction = sFactionStore.LookupEntry(my_faction->faction);
    if (raw_faction && raw_faction->reputationListID >= 0)
        return false;
 
    return my_faction->IsHostileToPlayers();
}

◆ IsHovering()

bool Unit::IsHovering ( ) const

inline

Definition at line 2377 of file Unit.h.

2377{ return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_HOVER); }

MOVEMENTFLAG_HOVER

@ MOVEMENTFLAG_HOVER

Definition: Unit.h:582

◆ IsHunterPet()

bool Unit::IsHunterPet ( ) const

inline

Definition at line 1414 of file Unit.h.

1414{ return m_unitTypeMask & UNIT_MASK_HUNTER_PET; }

UNIT_MASK_HUNTER_PET

@ UNIT_MASK_HUNTER_PET

Definition: Unit.h:682

◆ IsImmunedToDamage() [1/3]

bool Unit::IsImmunedToDamage ( Spell const * spell ) const

Definition at line 12699 of file Unit.cpp.

{
    SpellInfo const* spellInfo = spell->GetSpellInfo();
    if (!spellInfo)
    {
        return false;
    }
 
    if (spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES) && !HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
    {
        return false;
    }
 
    if (spellInfo->HasAttribute(SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS) || spellInfo->HasAttribute(SPELL_ATTR2_NO_SCHOOL_IMMUNITIES))
    {
        return false;
    }
 
    uint32 schoolMask = spell->GetSpellSchoolMask();
    if (schoolMask == SPELL_SCHOOL_MASK_NONE)
    {
        return false;
    }
 
    // If m_immuneToDamage type contain magic, IMMUNE damage.
    SpellImmuneList const& damageList = m_spellImmune[IMMUNITY_DAMAGE];
    for (SpellImmuneList::const_iterator itr = damageList.begin(); itr != damageList.end(); ++itr)
    {
        if ((itr->type & schoolMask) == schoolMask)
        {
            return true;
        }
    }
 
    return false;
}

◆ IsImmunedToDamage() [2/3]

bool Unit::IsImmunedToDamage ( SpellInfo const * spellInfo ) const

Definition at line 12667 of file Unit.cpp.

{
    if (!spellInfo)
    {
        return false;
    }
 
    if (spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES) && !HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
    {
        return false;
    }
 
    if (spellInfo->HasAttribute(SPELL_ATTR1_IMMUNITY_TO_HOSTILE_AND_FRIENDLY_EFFECTS) || spellInfo->HasAttribute(SPELL_ATTR2_NO_SCHOOL_IMMUNITIES))
    {
        return false;
    }
 
    uint32 schoolMask = spellInfo->GetSchoolMask();
    if (schoolMask == SPELL_SCHOOL_MASK_NONE)
    {
        return false;
    }
 
    // If m_immuneToDamage type contain magic, IMMUNE damage.
    SpellImmuneList const& damageList = m_spellImmune[IMMUNITY_DAMAGE];
    for (SpellImmuneList::const_iterator itr = damageList.begin(); itr != damageList.end(); ++itr)
        if((itr->type & schoolMask) == schoolMask)
            return true;
 
    return false;
}

◆ IsImmunedToDamage() [3/3]

bool Unit::IsImmunedToDamage ( SpellSchoolMask meleeSchoolMask ) const

Definition at line 12651 of file Unit.cpp.

{
    if (meleeSchoolMask == SPELL_SCHOOL_MASK_NONE)
    {
        return false;
    }
 
    // If m_immuneToDamage type contain magic, IMMUNE damage.
    SpellImmuneList const& damageList = m_spellImmune[IMMUNITY_DAMAGE];
    for (SpellImmuneList::const_iterator itr = damageList.begin(); itr != damageList.end(); ++itr)
        if((itr->type & meleeSchoolMask) == meleeSchoolMask)
            return true;
 
    return false;
}

◆ IsImmunedToDamageOrSchool() [1/2]

bool Unit::IsImmunedToDamageOrSchool ( SpellInfo const * spellInfo ) const

Definition at line 12815 of file Unit.cpp.

{
    return IsImmunedToDamage(spellInfo) || IsImmunedToSchool(spellInfo);
}

◆ IsImmunedToDamageOrSchool() [2/2]

bool Unit::IsImmunedToDamageOrSchool ( SpellSchoolMask meleeSchoolMask ) const

Definition at line 12805 of file Unit.cpp.

{
    if (meleeSchoolMask == SPELL_SCHOOL_MASK_NONE)
    {
        return false;
    }
 
    return IsImmunedToDamage(meleeSchoolMask) || IsImmunedToSchool(meleeSchoolMask);
}

◆ IsImmunedToSchool() [1/3]

bool Unit::IsImmunedToSchool ( Spell const * spell ) const

Definition at line 12775 of file Unit.cpp.

{
    SpellInfo const* spellInfo = spell->GetSpellInfo();
    if (spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES) && !HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
    {
        return false;
    }
 
    uint32 schoolMask = spell->GetSpellSchoolMask();
    if (schoolMask == SPELL_SCHOOL_MASK_NONE)
    {
        return false;
    }
 
    if (spellInfo->Id != 42292 && spellInfo->Id != 59752 && spellInfo->Id != 19574 && spellInfo->Id != 34471)
    {
        // If m_immuneToSchool type contain this school type, IMMUNE damage.
        SpellImmuneList const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
        for (SpellImmuneList::const_iterator itr = schoolList.begin(); itr != schoolList.end(); ++itr)
        {
            if ((itr->type & schoolMask) == schoolMask && !spellInfo->CanPierceImmuneAura(sSpellMgr->GetSpellInfo(itr->spellId)))
            {
                return true;
            }
        }
    }
 
    return false;
}

◆ IsImmunedToSchool() [2/3]

bool Unit::IsImmunedToSchool ( SpellInfo const * spellInfo ) const

Definition at line 12752 of file Unit.cpp.

{
    if (spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES) && !HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
        return false;
 
    uint32 schoolMask = spellInfo->GetSchoolMask();
    if (schoolMask == SPELL_SCHOOL_MASK_NONE)
    {
        return false;
    }
 
    if (spellInfo->Id != 42292 && spellInfo->Id != 59752 && spellInfo->Id != 19574 && spellInfo->Id != 34471)
    {
        // If m_immuneToSchool type contain this school type, IMMUNE damage.
        SpellImmuneList const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
        for (SpellImmuneList::const_iterator itr = schoolList.begin(); itr != schoolList.end(); ++itr)
            if((itr->type & schoolMask) == schoolMask && !spellInfo->CanPierceImmuneAura(sSpellMgr->GetSpellInfo(itr->spellId)))
                return true;
    }
 
    return false;
}

◆ IsImmunedToSchool() [3/3]

bool Unit::IsImmunedToSchool ( SpellSchoolMask meleeSchoolMask ) const

Definition at line 12736 of file Unit.cpp.

{
    if (meleeSchoolMask == SPELL_SCHOOL_MASK_NONE)
    {
        return false;
    }
 
    // If m_immuneToSchool type contain this school type, IMMUNE damage.
    SpellImmuneList const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
    for (SpellImmuneList::const_iterator itr = schoolList.begin(); itr != schoolList.end(); ++itr)
        if((itr->type & meleeSchoolMask) == meleeSchoolMask)
            return true;
 
    return false;
}

◆ IsImmunedToSpell()

bool Unit::IsImmunedToSpell	(	SpellInfo const *	spellInfo,
		Spell const *	spell = `nullptr`
	)

virtual

Reimplemented in Creature.

Definition at line 12820 of file Unit.cpp.

{
    if (!spellInfo)
        return false;
 
    // Single spell immunity.
    SpellImmuneList const& idList = m_spellImmune[IMMUNITY_ID];
    for (SpellImmuneList::const_iterator itr = idList.begin(); itr != idList.end(); ++itr)
        if (itr->type == spellInfo->Id)
            return true;
 
    // xinef: my special immunity, if spellid is not on this list it means npc is immune
    SpellImmuneList const& allowIdList = m_spellImmune[IMMUNITY_ALLOW_ID];
    if (!allowIdList.empty())
    {
        for (SpellImmuneList::const_iterator itr = allowIdList.begin(); itr != allowIdList.end(); ++itr)
            if (itr->type == spellInfo->Id)
                return false;
        return true;
    }
 
    if (spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES) && !HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
        return false;
 
    if (spellInfo->Dispel)
    {
        SpellImmuneList const& dispelList = m_spellImmune[IMMUNITY_DISPEL];
        for (SpellImmuneList::const_iterator itr = dispelList.begin(); itr != dispelList.end(); ++itr)
            if (itr->type == spellInfo->Dispel)
                return true;
    }
 
    // Spells that don't have effectMechanics.
    if (spellInfo->Mechanic)
    {
        SpellImmuneList const& mechanicList = m_spellImmune[IMMUNITY_MECHANIC];
        for (SpellImmuneList::const_iterator itr = mechanicList.begin(); itr != mechanicList.end(); ++itr)
            if (itr->type == spellInfo->Mechanic)
                return true;
    }
 
    bool immuneToAllEffects = true;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        // State/effect immunities applied by aura expect full spell immunity
        // Ignore effects with mechanic, they are supposed to be checked separately
        if (!spellInfo->Effects[i].IsEffect())
            continue;
 
        // Xinef: if target is immune to one effect, and the spell has transform aura - it is immune to whole spell
        if (IsImmunedToSpellEffect(spellInfo, i))
        {
            if (spellInfo->HasAura(SPELL_AURA_TRANSFORM))
                return true;
            continue;
        }
 
        immuneToAllEffects = false;
        break;
    }
    if (immuneToAllEffects) //Return immune only if the target is immune to all spell effects.
        return true;
 
    if (spellInfo->Id != 42292 && spellInfo->Id != 59752 && spellInfo->Id != 19574 && spellInfo->Id != 34471)
    {
        SpellSchoolMask spellSchoolMask = spellInfo->GetSchoolMask();
        if (spell)
        {
            spellSchoolMask = spell->GetSpellSchoolMask();
        }
 
        if (spellSchoolMask != SPELL_SCHOOL_MASK_NONE)
        {
            SpellImmuneList const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
            for (SpellImmuneList::const_iterator itr = schoolList.begin(); itr != schoolList.end(); ++itr)
            {
                SpellInfo const* immuneSpellInfo = sSpellMgr->GetSpellInfo(itr->spellId);
                if (((itr->type & spellSchoolMask) == spellSchoolMask)
                    && (!immuneSpellInfo || immuneSpellInfo->IsPositive()) && !spellInfo->IsPositive()
                    && !spellInfo->CanPierceImmuneAura(immuneSpellInfo))
                {
                    return true;
                }
            }
        }
    }
 
    return false;
}

◆ IsImmunedToSpellEffect()

bool Unit::IsImmunedToSpellEffect	(	SpellInfo const *	spellInfo,
		uint32	index
	)		const

virtual

Reimplemented in Creature, and Totem.

Definition at line 12910 of file Unit.cpp.

{
    if (!spellInfo || !spellInfo->Effects[index].IsEffect())
        return false;
 
    // xinef: pet scaling auras
    if (spellInfo->HasAttribute(SPELL_ATTR4_OWNER_POWER_SCALING))
        return false;
 
    if (spellInfo->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES) && !HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
        return false;
 
    //If m_immuneToEffect type contain this effect type, IMMUNE effect.
    uint32 effect = spellInfo->Effects[index].Effect;
    SpellImmuneList const& effectList = m_spellImmune[IMMUNITY_EFFECT];
    for (SpellImmuneList::const_iterator itr = effectList.begin(); itr != effectList.end(); ++itr)
    {
        if (itr->type == effect && (itr->spellId != 62692 || (spellInfo->Effects[index].MiscValue == POWER_MANA && !CanRestoreMana(spellInfo))))
        {
            return true;
        }
    }
 
    if (uint32 mechanic = spellInfo->Effects[index].Mechanic)
    {
        SpellImmuneList const& mechanicList = m_spellImmune[IMMUNITY_MECHANIC];
        for (SpellImmuneList::const_iterator itr = mechanicList.begin(); itr != mechanicList.end(); ++itr)
            if (itr->type == mechanic)
                return true;
    }
 
    if (uint32 aura = spellInfo->Effects[index].ApplyAuraName)
    {
        SpellImmuneList const& list = m_spellImmune[IMMUNITY_STATE];
        for (SpellImmuneList::const_iterator itr = list.begin(); itr != list.end(); ++itr)
        {
            if (itr->type == aura && (itr->spellId != 64848 || (spellInfo->Effects[index].MiscValue == POWER_MANA && !CanRestoreMana(spellInfo))))
            {
                if (!spellInfo->HasAttribute(SPELL_ATTR3_ALWAYS_HIT))
                {
                    if (itr->blockType == SPELL_BLOCK_TYPE_ALL || spellInfo->IsPositive()) // xinef: added for pet scaling
                    {
                        return true;
                    }
                }
            }
        }
 
        if (!spellInfo->HasAttribute(SPELL_ATTR2_NO_SCHOOL_IMMUNITIES))
        {
            // Check for immune to application of harmful magical effects
            AuraEffectList const& immuneAuraApply = GetAuraEffectsByType(SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL);
            for (AuraEffectList::const_iterator iter = immuneAuraApply.begin(); iter != immuneAuraApply.end(); ++iter)
            {
                if (/*(spellInfo->Dispel == DISPEL_MAGIC || spellInfo->Dispel == DISPEL_CURSE || spellInfo->Dispel == DISPEL_DISEASE) &&*/ // Magic debuff, xinef: all kinds?
                    ((*iter)->GetMiscValue() & spellInfo->GetSchoolMask()) &&  // Check school
                    !spellInfo->IsPositiveEffect(index) &&                                  // Harmful
                    spellInfo->Effects[index].Effect != SPELL_EFFECT_PERSISTENT_AREA_AURA)  // Not Persistent area auras
                {
                    return true;
                }
            }
        }
    }
 
    return false;
}

◆ IsImmuneToAll()

bool Unit::IsImmuneToAll ( ) const

inline

Definition at line 1676 of file Unit.h.

1676{ return IsImmuneToPC() && IsImmuneToNPC(); }

◆ IsImmuneToNPC()

bool Unit::IsImmuneToNPC ( ) const

inline

Definition at line 1680 of file Unit.h.

1680{ return HasUnitFlag(UNIT_FLAG_IMMUNE_TO_NPC); }

UNIT_FLAG_IMMUNE_TO_NPC

@ UNIT_FLAG_IMMUNE_TO_NPC

Definition: Unit.h:457

◆ IsImmuneToPC()

bool Unit::IsImmuneToPC ( ) const

inline

Definition at line 1678 of file Unit.h.

1678{ return HasUnitFlag(UNIT_FLAG_IMMUNE_TO_PC); }

◆ isInAccessiblePlaceFor()

bool Unit::isInAccessiblePlaceFor ( Creature const * c ) const

Definition at line 4121 of file Unit.cpp.

{
    if (c->GetMapId() == 618) // Ring of Valor
    {
        // skip transport check, check for being below floor level
        if (this->GetPositionZ() < 28.0f)
            return false;
        if (BattlegroundMap* bgMap = c->GetMap()->ToBattlegroundMap())
            if (Battleground* bg = bgMap->GetBG())
                if (bg->GetStartTime() < 80133) // 60000ms preparation time + 20133ms elevator rise time
                    return false;
    }
    else if (c->GetMapId() == 631) // Icecrown Citadel
    {
        // if static transport doesn't match - return false
        if (c->GetTransport() != this->GetTransport() && ((c->GetTransport() && c->GetTransport()->IsStaticTransport()) || (this->GetTransport() && this->GetTransport()->IsStaticTransport())))
            return false;
 
        // special handling for ICC (map 631), for non-flying pets in Gunship Battle, for trash npcs this is done via CanAIAttack
        if (c->GetOwnerGUID().IsPlayer() && !c->CanFly())
        {
            if (c->GetTransport() != this->GetTransport())
                return false;
            if (this->GetTransport())
            {
                if (c->GetPositionY() < 2033.0f)
                {
                    if (this->GetPositionY() > 2033.0f)
                        return false;
                }
                else if (c->GetPositionY() < 2438.0f)
                {
                    if (this->GetPositionY() < 2033.0f || this->GetPositionY() > 2438.0f)
                        return false;
                }
                else if (this->GetPositionY() < 2438.0f)
                    return false;
            }
        }
    }
    else
    {
        // pussywizard: prevent any bugs by passengers exiting transports or normal creatures flying away
        if (c->GetTransport() != this->GetTransport())
            return false;
    }
 
    LiquidStatus liquidStatus = GetLiquidData().Status;
    bool isInWater = (liquidStatus & MAP_LIQUID_STATUS_SWIMMING) != 0;
 
    // In water or jumping in water
    if (isInWater || (liquidStatus == LIQUID_MAP_ABOVE_WATER && (IsFalling() || (ToPlayer() && ToPlayer()->IsFalling()))))
    {
        return c->CanEnterWater();
    }
    else
    {
        return c->CanWalk() || c->CanFly();
    }
}

◆ isInBackInMap()

bool Unit::isInBackInMap	(	Unit const *	target,
		float	distance,
		float	arc = `M_PI`
	)		const

Definition at line 4116 of file Unit.cpp.

{
    return IsWithinDistInMap(target, distance) && !HasInArc(2 * M_PI - arc, target);
}

◆ IsInCombat()

bool Unit::IsInCombat ( ) const

inline

Definition at line 1685 of file Unit.h.

1685{ return HasUnitFlag(UNIT_FLAG_IN_COMBAT); }

◆ IsInCombatWith()

bool Unit::IsInCombatWith ( Unit const * who ) const

Definition at line 21042 of file Unit.cpp.

{
    // Check target exists
    if (!who)
        return false;
    // Search in threat list
    ObjectGuid guid = who->GetGUID();
    for (ThreatContainer::StorageType::const_iterator i = m_ThreatMgr.GetThreatList().begin(); i != m_ThreatMgr.GetThreatList().end(); ++i)
    {
        HostileReference* ref = (*i);
        // Return true if the unit matches
        if (ref && ref->getUnitGuid() == guid)
            return true;
    }
    // Nothing found, false.
    return false;
}

◆ IsInDisallowedMountForm()

bool Unit::IsInDisallowedMountForm ( ) const

Definition at line 21244 of file Unit.cpp.

{
    if (SpellInfo const* transformSpellInfo = sSpellMgr->GetSpellInfo(getTransForm()))
    {
        if (transformSpellInfo->HasAttribute(SPELL_ATTR0_ALLOW_WHILE_MOUNTED))
        {
            return false;
        }
    }
 
    if (ShapeshiftForm form = GetShapeshiftForm())
    {
        SpellShapeshiftEntry const* shapeshift = sSpellShapeshiftStore.LookupEntry(form);
        if (!shapeshift)
        {
            return true;
        }
 
        if (!(shapeshift->flags1 & 0x1))
        {
            return true;
        }
    }
 
    if (GetDisplayId() == GetNativeDisplayId())
    {
        return false;
    }
 
    CreatureDisplayInfoEntry const* display = sCreatureDisplayInfoStore.LookupEntry(GetDisplayId());
    if (!display)
    {
        return true;
    }
 
    CreatureDisplayInfoExtraEntry const* displayExtra = sCreatureDisplayInfoExtraStore.LookupEntry(display->ExtendedDisplayInfoID);
    if (!displayExtra)
    {
        return true;
    }
 
    CreatureModelDataEntry const* model = sCreatureModelDataStore.LookupEntry(display->ModelId);
    ChrRacesEntry const* race = sChrRacesStore.LookupEntry(displayExtra->DisplayRaceID);
 
    if (model && !(model->HasFlag(CREATURE_MODEL_DATA_FLAGS_CAN_MOUNT)))
    {
        if (race && !(race->HasFlag(CHRRACES_FLAGS_CAN_MOUNT)))
        {
            return true;
        }
    }
 
    return false;
}

◆ IsInFeralForm()

bool Unit::IsInFeralForm ( ) const

inline

Definition at line 2074 of file Unit.h.

    {
        ShapeshiftForm form = GetShapeshiftForm();
        return form == FORM_CAT || form == FORM_BEAR || form == FORM_DIREBEAR || form == FORM_GHOSTWOLF; // Xinef: added shamans Ghost Wolf, should behave exactly like druid forms
    }

◆ IsInFlight()

bool Unit::IsInFlight ( ) const

inline

Definition at line 1673 of file Unit.h.

1673{ return HasUnitState(UNIT_STATE_IN_FLIGHT); }

◆ isInFrontInMap()

bool Unit::isInFrontInMap	(	Unit const *	target,
		float	distance,
		float	arc = `M_PI`
	)		const

Definition at line 4111 of file Unit.cpp.

{
    return IsWithinDistInMap(target, distance) && HasInArc(arc, target);
}

◆ IsInnkeeper()

bool Unit::IsInnkeeper ( ) const

inline

Definition at line 1656 of file Unit.h.

1656{ return HasNpcFlag(UNIT_NPC_FLAG_INNKEEPER); }

UNIT_NPC_FLAG_INNKEEPER

@ UNIT_NPC_FLAG_INNKEEPER

Definition: Unit.h:532

◆ IsInPartyWith()

bool Unit::IsInPartyWith ( Unit const * unit ) const

Definition at line 18806 of file Unit.cpp.

{
    if (this == unit)
        return true;
 
    Unit const* u1 = GetCharmerOrOwnerOrSelf();
    Unit const* u2 = unit->GetCharmerOrOwnerOrSelf();
    if (u1 == u2)
        return true;
 
    if (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_PLAYER)
        return u1->ToPlayer()->IsInSameGroupWith(u2->ToPlayer());
    // Xinef: we assume that npcs with the same faction are in party
    else if (u1->GetTypeId() == TYPEID_UNIT && u2->GetTypeId() == TYPEID_UNIT && !u1->IsControlledByPlayer() && !u2->IsControlledByPlayer())
        return u1->GetFaction() == u2->GetFaction();
    // Xinef: creature type_flag should work for party check only if player group is not a raid
    else if ((u2->GetTypeId() == TYPEID_PLAYER && u1->GetTypeId() == TYPEID_UNIT && (u1->ToCreature()->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_TREAT_AS_RAID_UNIT) && u2->ToPlayer()->GetGroup() && !u2->ToPlayer()->GetGroup()->isRaidGroup()) ||
             (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_UNIT && (u2->ToCreature()->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_TREAT_AS_RAID_UNIT) && u1->ToPlayer()->GetGroup() && !u1->ToPlayer()->GetGroup()->isRaidGroup()))
        return true;
    else
        return false;
}

◆ IsInRaidWith()

bool Unit::IsInRaidWith ( Unit const * unit ) const

Definition at line 18829 of file Unit.cpp.

{
    if (this == unit)
        return true;
 
    Unit const* u1 = GetCharmerOrOwnerOrSelf();
    Unit const* u2 = unit->GetCharmerOrOwnerOrSelf();
    if (u1 == u2)
        return true;
 
    if (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_PLAYER)
        return u1->ToPlayer()->IsInSameRaidWith(u2->ToPlayer());
    // Xinef: we assume that npcs with the same faction are in party
    else if (u1->GetTypeId() == TYPEID_UNIT && u2->GetTypeId() == TYPEID_UNIT && !u1->IsControlledByPlayer() && !u2->IsControlledByPlayer())
        return u1->GetFaction() == u2->GetFaction();
    else if ((u2->GetTypeId() == TYPEID_PLAYER && u1->GetTypeId() == TYPEID_UNIT && u1->ToCreature()->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_TREAT_AS_RAID_UNIT) ||
             (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_UNIT && u2->ToCreature()->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_TREAT_AS_RAID_UNIT))
        return true;
    else
        return false;
}

◆ isInRoots()

bool Unit::isInRoots ( ) const

inline

Definition at line 1706 of file Unit.h.

1706{ return HasAuraType(SPELL_AURA_MOD_ROOT); }

◆ IsInSanctuary()

bool Unit::IsInSanctuary ( ) const

inline

Definition at line 1514 of file Unit.h.

1514{ return HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_SANCTUARY); }

◆ IsInWater()

bool Unit::IsInWater ( ) const

virtual

Reimplemented in Player.

Definition at line 4267 of file Unit.cpp.

{
    return (GetLiquidData().Status & MAP_LIQUID_STATUS_SWIMMING) != 0;
}

◆ IsLevitating()

bool Unit::IsLevitating ( ) const

inline

Definition at line 2373 of file Unit.h.

2373{ return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY); }

◆ IsMounted()

bool Unit::IsMounted ( ) const

inline

Definition at line 1540 of file Unit.h.

1540{ return HasUnitFlag(UNIT_FLAG_MOUNT); }

◆ IsMovementPreventedByCasting()

bool Unit::IsMovementPreventedByCasting ( ) const

virtual

Reimplemented in Creature.

Definition at line 4087 of file Unit.cpp.

{
    // can always move when not casting
    if (!HasUnitState(UNIT_STATE_CASTING))
    {
        return false;
    }
 
    // channeled spells during channel stage (after the initial cast timer) allow movement with a specific spell attribute
    if (Spell* spell = m_currentSpells[CURRENT_CHANNELED_SPELL])
    {
        if (spell->getState() != SPELL_STATE_FINISHED && spell->IsChannelActive())
        {
            if (spell->GetSpellInfo()->IsActionAllowedChannel())
            {
                return false;
            }
        }
    }
 
    // prohibit movement for all other spell casts
    return true;
}

◆ isMoving()

bool Unit::isMoving ( ) const

inline

Definition at line 2375 of file Unit.h.

2375{ return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_MASK_MOVING); }

MOVEMENTFLAG_MASK_MOVING

@ MOVEMENTFLAG_MASK_MOVING

Definition: Unit.h:585

◆ IsNeutralToAll()

bool Unit::IsNeutralToAll ( ) const

Definition at line 10220 of file Unit.cpp.

{
    FactionTemplateEntry const* my_faction = GetFactionTemplateEntry();
    if (!my_faction || !my_faction->faction)
        return true;
 
    FactionEntry const* raw_faction = sFactionStore.LookupEntry(my_faction->faction);
    if (raw_faction && raw_faction->reputationListID >= 0)
        return false;
 
    return my_faction->IsNeutralToAll();
}

◆ IsNonMeleeSpellCast()

bool Unit::IsNonMeleeSpellCast	(	bool	withDelayed,
		bool	skipChanneled = `false`,
		bool	skipAutorepeat = `false`,
		bool	isAutoshoot = `false`,
		bool	skipInstant = `true`
	)		const

Definition at line 4027 of file Unit.cpp.

{
    // We don't do loop here to explicitly show that melee spell is excluded.
    // Maybe later some special spells will be excluded too.
 
    // generic spells are cast when they are not finished and not delayed
    if (m_currentSpells[CURRENT_GENERIC_SPELL] &&
            (m_currentSpells[CURRENT_GENERIC_SPELL]->getState() != SPELL_STATE_FINISHED) &&
            (withDelayed || m_currentSpells[CURRENT_GENERIC_SPELL]->getState() != SPELL_STATE_DELAYED))
    {
        if (!skipInstant || m_currentSpells[CURRENT_GENERIC_SPELL]->GetCastTime())
        {
            if (!isAutoshoot || !m_currentSpells[CURRENT_GENERIC_SPELL]->m_spellInfo->HasAttribute(SPELL_ATTR2_DO_NOT_RESET_COMBAT_TIMERS))
                return true;
        }
    }
    // channeled spells may be delayed, but they are still considered cast
    if (!skipChanneled && m_currentSpells[CURRENT_CHANNELED_SPELL] &&
            (m_currentSpells[CURRENT_CHANNELED_SPELL]->getState() != SPELL_STATE_FINISHED))
    {
        if (!isAutoshoot || !m_currentSpells[CURRENT_CHANNELED_SPELL]->m_spellInfo->HasAttribute(SPELL_ATTR2_DO_NOT_RESET_COMBAT_TIMERS))
            return true;
    }
    // autorepeat spells may be finished or delayed, but they are still considered cast
    if (!skipAutorepeat && m_currentSpells[CURRENT_AUTOREPEAT_SPELL])
        return true;
 
    return false;
}

◆ IsOnVehicle()

bool Unit::IsOnVehicle ( Unit const * vehicle ) const

inline

Definition at line 2350 of file Unit.h.

2350{ return m_vehicle && m_vehicle == vehicle->GetVehicleKit(); }

◆ IsPet()

bool Unit::IsPet ( ) const

inline

Definition at line 1413 of file Unit.h.

1413{ return m_unitTypeMask & UNIT_MASK_PET; }

UNIT_MASK_PET

@ UNIT_MASK_PET

Definition: Unit.h:679

◆ IsPetAura()

bool Unit::IsPetAura ( Aura const * aura )

Definition at line 17386 of file Unit.cpp.

{
    Unit* owner = GetOwner();
 
    if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
        return false;
 
    // if the owner has that pet aura, return true
    for (PetAura const* petAura : owner->m_petAuras)
        if (petAura->GetAura(GetEntry()) == aura->GetId())
            return true;
 
    return false;
}

◆ IsPetInCombat()

bool Unit::IsPetInCombat ( ) const

inline

Definition at line 1688 of file Unit.h.

1688{ return HasUnitFlag(UNIT_FLAG_PET_IN_COMBAT); }

◆ IsPolymorphed()

bool Unit::IsPolymorphed ( ) const

Definition at line 16827 of file Unit.cpp.

{
    uint32 transformId = getTransForm();
    if (!transformId)
        return false;
 
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(transformId);
    if (!spellInfo)
        return false;
 
    return spellInfo->GetSpellSpecific() == SPELL_SPECIFIC_MAGE_POLYMORPH;
}

◆ isPossessed()

bool Unit::isPossessed ( ) const

inline

Definition at line 1869 of file Unit.h.

1869{ return HasUnitState(UNIT_STATE_POSSESSED); }

◆ isPossessedByPlayer()

bool Unit::isPossessedByPlayer ( ) const

inline

Definition at line 1870 of file Unit.h.

1870{ return HasUnitState(UNIT_STATE_POSSESSED) && GetCharmerGUID().IsPlayer(); }

◆ isPossessing() [1/2]

bool Unit::isPossessing ( ) const

inline

Definition at line 1871 of file Unit.h.

    {
        if (Unit* u = GetCharm())
            return u->isPossessed();
        else
            return false;
    }

◆ isPossessing() [2/2]

bool Unit::isPossessing ( Unit * u ) const

inline

Definition at line 1878 of file Unit.h.

1878{ return u->isPossessed() && GetCharmGUID() == u->GetGUID(); }

Unit::isPossessed

bool isPossessed() const

Definition: Unit.h:1869

◆ IsPvP()

bool Unit::IsPvP ( ) const

inline

Definition at line 1515 of file Unit.h.

1515{ return HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP); }

UNIT_BYTE2_FLAG_PVP

@ UNIT_BYTE2_FLAG_PVP

Definition: Unit.h:136

◆ IsQuestGiver()

bool Unit::IsQuestGiver ( ) const

inline

Definition at line 1650 of file Unit.h.

1650{ return HasNpcFlag(UNIT_NPC_FLAG_QUESTGIVER); }

UNIT_NPC_FLAG_QUESTGIVER

@ UNIT_NPC_FLAG_QUESTGIVER

Definition: Unit.h:517

◆ IsScriptOverriden()

AuraEffect * Unit::IsScriptOverriden	(	SpellInfo const *	spell,
		int32	script
	)		const

Definition at line 5709 of file Unit.cpp.

{
    AuraEffectList const& auras = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
    for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
    {
        if ((*i)->GetMiscValue() == script)
            if ((*i)->IsAffectedOnSpell(spell))
                return (*i);
    }
    return nullptr;
}

◆ IsServiceProvider()

bool Unit::IsServiceProvider ( ) const

inline

Definition at line 1662 of file Unit.h.

    {
        return HasFlag(UNIT_NPC_FLAGS,
                       UNIT_NPC_FLAG_VENDOR | UNIT_NPC_FLAG_TRAINER | UNIT_NPC_FLAG_FLIGHTMASTER |
                       UNIT_NPC_FLAG_PETITIONER | UNIT_NPC_FLAG_BATTLEMASTER | UNIT_NPC_FLAG_BANKER |
                       UNIT_NPC_FLAG_INNKEEPER | UNIT_NPC_FLAG_SPIRITHEALER |
                       UNIT_NPC_FLAG_SPIRITGUIDE | UNIT_NPC_FLAG_TABARDDESIGNER | UNIT_NPC_FLAG_AUCTIONEER);
    }

◆ IsSitState()

bool Unit::IsSitState ( ) const

Definition at line 16797 of file Unit.cpp.

{
    uint8 s = getStandState();
    return
        s == UNIT_STAND_STATE_SIT_CHAIR        || s == UNIT_STAND_STATE_SIT_LOW_CHAIR  ||
        s == UNIT_STAND_STATE_SIT_MEDIUM_CHAIR || s == UNIT_STAND_STATE_SIT_HIGH_CHAIR ||
        s == UNIT_STAND_STATE_SIT;
}

◆ isSpellBlocked()

bool Unit::isSpellBlocked	(	Unit *	victim,
		SpellInfo const *	spellProto,
		WeaponAttackType	attackType = `BASE_ATTACK`
	)

Definition at line 3042 of file Unit.cpp.

{
    // These spells can't be blocked
    if (spellProto && spellProto->HasAttribute(SPELL_ATTR0_NO_ACTIVE_DEFENSE))
        return false;
 
    if (victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION) || victim->HasInArc(M_PI, this))
    {
        // Check creatures flags_extra for disable block
        if (victim->GetTypeId() == TYPEID_UNIT &&
                victim->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_BLOCK)
            return false;
 
        float blockChance = victim->GetUnitBlockChance();
        blockChance += (int32(GetWeaponSkillValue(attackType)) - int32(victim->GetMaxSkillValueForLevel())) * 0.04f;
 
        // xinef: cant block while casting or while stunned
        if (blockChance < 0.0f || victim->IsNonMeleeSpellCast(false, false, true) || victim->HasUnitState(UNIT_STATE_CONTROLLED))
            blockChance = 0.0f;
 
        if (roll_chance_f(blockChance))
            return true;
    }
    return false;
}

◆ IsSpiritGuide()

bool Unit::IsSpiritGuide ( ) const

inline

Definition at line 1658 of file Unit.h.

1658{ return HasNpcFlag(UNIT_NPC_FLAG_SPIRITGUIDE); }

◆ IsSpiritHealer()

bool Unit::IsSpiritHealer ( ) const

inline

Definition at line 1657 of file Unit.h.

1657{ return HasNpcFlag(UNIT_NPC_FLAG_SPIRITHEALER); }

◆ IsSpiritService()

bool Unit::IsSpiritService ( ) const

inline

Definition at line 1670 of file Unit.h.

1670{ return HasNpcFlag(UNIT_NPC_FLAG_SPIRITHEALER | UNIT_NPC_FLAG_SPIRITGUIDE); }

◆ IsStandState()

bool Unit::IsStandState ( ) const

Definition at line 16806 of file Unit.cpp.

{
    uint8 s = getStandState();
    return !IsSitState() && s != UNIT_STAND_STATE_SLEEP && s != UNIT_STAND_STATE_KNEEL;
}

◆ IsStopped()

bool Unit::IsStopped ( ) const

inline

Definition at line 2261 of file Unit.h.

2261{ return !(HasUnitState(UNIT_STATE_MOVING)); }

UNIT_STATE_MOVING

@ UNIT_STATE_MOVING

Definition: Unit.h:364

◆ IsSummon()

bool Unit::IsSummon ( ) const

inline

Definition at line 1410 of file Unit.h.

1410{ return m_unitTypeMask & UNIT_MASK_SUMMON; }

UNIT_MASK_SUMMON

@ UNIT_MASK_SUMMON

Definition: Unit.h:675

◆ isSwimming()

bool Unit::isSwimming ( ) const

inline

Definition at line 2378 of file Unit.h.

2378{ return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_SWIMMING); }

◆ IsTabardDesigner()

bool Unit::IsTabardDesigner ( ) const

inline

Definition at line 1659 of file Unit.h.

1659{ return HasNpcFlag(UNIT_NPC_FLAG_TABARDDESIGNER); }

◆ isTargetableForAttack()

bool Unit::isTargetableForAttack	(	bool	checkFakeDeath = `true`,
		Unit const *	byWho = `nullptr`
	)		const

Definition at line 13747 of file Unit.cpp.

{
    if (!IsAlive())
        return false;
 
    if (HasUnitFlag(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE))
        return false;
 
    if (IsImmuneToPC() && byWho && byWho->GetCharmerOrOwnerPlayerOrPlayerItself())
        return false;
 
    if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->IsGameMaster())
        return false;
 
    return !HasUnitState(UNIT_STATE_UNATTACKABLE) && (!checkFakeDeath || !HasUnitState(UNIT_STATE_DIED));
}

◆ IsTaxi()

bool Unit::IsTaxi ( ) const

inline

Definition at line 1652 of file Unit.h.

1652{ return HasNpcFlag(UNIT_NPC_FLAG_FLIGHTMASTER); }

◆ IsTotem()

bool Unit::IsTotem ( ) const

inline

Definition at line 1415 of file Unit.h.

1415{ return m_unitTypeMask & UNIT_MASK_TOTEM; }

UNIT_MASK_TOTEM

@ UNIT_MASK_TOTEM

Definition: Unit.h:678

◆ IsTrainer()

bool Unit::IsTrainer ( ) const

inline

Definition at line 1649 of file Unit.h.

1649{ return HasNpcFlag(UNIT_NPC_FLAG_TRAINER); }

◆ IsTriggeredAtSpellProcEvent()

bool Unit::IsTriggeredAtSpellProcEvent	(	Unit *	victim,
		Aura *	aura,
		WeaponAttackType	attType,
		bool	isVictim,
		bool	active,
		SpellProcEventEntry const *&	spellProcEvent,
		ProcEventInfo const &	eventInfo
	)

private

Definition at line 17473 of file Unit.cpp.

{
    SpellInfo const* spellProto = aura->GetSpellInfo();
    SpellInfo const* procSpell = eventInfo.GetSpellInfo();
 
    // let the aura be handled by new proc system if it has new entry
    if (sSpellMgr->GetSpellProcEntry(spellProto->Id))
        return false;
 
    // Get proc Event Entry
    spellProcEvent = sSpellMgr->GetSpellProcEvent(spellProto->Id);
 
    // Get EventProcFlag
    uint32 EventProcFlag;
    if (spellProcEvent && spellProcEvent->procFlags) // if exist get custom spellProcEvent->procFlags
        EventProcFlag = spellProcEvent->procFlags;
    else
        EventProcFlag = spellProto->ProcFlags;       // else get from spell proto
    // Continue if no trigger exist
    if (!EventProcFlag)
        return false;
 
    // Additional checks for triggered spells (ignore trap casts)
    //if (procExtra & PROC_EX_INTERNAL_TRIGGERED && !(procFlag & PROC_FLAG_DONE_TRAP_ACTIVATION))
    //{
    //    if (!spellProto->HasAttribute(SPELL_ATTR3_CAN_PROC_TRIGGERED))
    //        return false;
    //}
 
    // Xinef: additional check for player auras - only player spells can trigger player proc auras
    // Xinef: skip victim auras
    // Excluded player shoot spells
    // Excluded player item spells
    if (!isVictim && IsPlayer() && !(EventProcFlag & (PROC_FLAG_KILL | PROC_FLAG_DEATH)))
    {
        if (procSpell && procSpell->SpellFamilyName == SPELLFAMILY_GENERIC && procSpell->GetCategory() != 76 &&
            (!eventInfo.GetProcSpell() || !eventInfo.GetProcSpell()->m_CastItem) &&
            (!eventInfo.GetTriggerAuraSpell() || eventInfo.GetTriggerAuraSpell()->SpellFamilyName == SPELLFAMILY_GENERIC))
        {
            return false;
        }
    }
 
    // Check spellProcEvent data requirements
    if (!sSpellMgr->IsSpellProcEventCanTriggeredBy(spellProto, spellProcEvent, EventProcFlag, eventInfo, active))
        return false;
    // In most cases req get honor or XP from kill
    if (EventProcFlag & PROC_FLAG_KILL && GetTypeId() == TYPEID_PLAYER)
    {
        bool allow = false;
 
        if (victim)
            allow = ToPlayer()->isHonorOrXPTarget(victim);
 
        // Shadow Word: Death - can trigger from every kill
        if (aura->GetId() == 32409 || aura->GetId() == 18372 || aura->GetId() == 18213)
            allow = true;
        if (!allow)
            return false;
    }
    // Aura added by spell can`t trigger from self (prevent drop charges/do triggers)
    // But except periodic and kill triggers (can triggered from self)
    if (procSpell && procSpell->Id == spellProto->Id
            && !(spellProto->ProcFlags & (PROC_FLAG_TAKEN_PERIODIC | PROC_FLAG_KILL)))
        return false;
 
    // Check if current equipment allows aura to proc
    if (!isVictim && GetTypeId() == TYPEID_PLAYER && !spellProto->HasAttribute(SPELL_ATTR3_NO_PROC_EQUIP_REQUIREMENT))
    {
        Player* player = ToPlayer();
        if (spellProto->EquippedItemClass == ITEM_CLASS_WEAPON)
        {
            Item* item = nullptr;
            if (attType == BASE_ATTACK)
                item = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
            else if (attType == OFF_ATTACK)
                item = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
            else
                item = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_RANGED);
 
            if (player->IsInFeralForm())
                return false;
 
            if (!item || item->IsBroken() || item->GetTemplate()->Class != ITEM_CLASS_WEAPON || !((1 << item->GetTemplate()->SubClass) & spellProto->EquippedItemSubClassMask))
                return false;
        }
        else if (spellProto->EquippedItemClass == ITEM_CLASS_ARMOR)
        {
            // Check if player is wearing shield
            Item* item = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
            if (!item || item->IsBroken() || item->GetTemplate()->Class != ITEM_CLASS_ARMOR || !((1 << item->GetTemplate()->SubClass) & spellProto->EquippedItemSubClassMask))
                return false;
        }
    }
    // Get chance from spell
    float chance = float(spellProto->ProcChance);
    // If in spellProcEvent exist custom chance, chance = spellProcEvent->customChance;
    if (spellProcEvent && spellProcEvent->customChance)
        chance = spellProcEvent->customChance;
    // If PPM exist calculate chance from PPM
    if (spellProcEvent && spellProcEvent->ppmRate != 0)
    {
        if (!isVictim)
        {
            uint32 WeaponSpeed = GetAttackTime(attType);
            chance = GetPPMProcChance(WeaponSpeed, spellProcEvent->ppmRate, spellProto);
        }
        else if (victim)
        {
            uint32 WeaponSpeed = victim->GetAttackTime(attType);
            chance = victim->GetPPMProcChance(WeaponSpeed, spellProcEvent->ppmRate, spellProto);
        }
    }
 
    // Custom chances
    switch (spellProto->SpellFamilyName)
    {
        case SPELLFAMILY_WARRIOR:
            {
                // Recklessness, allow to proc only once for whirlwind
                if (spellProto->Id == 1719 && procSpell && procSpell->Id == 44949)
                    return false;
            }
    }
 
    if (eventInfo.GetProcChance())
    {
        chance = *eventInfo.GetProcChance();
    }
 
    // Apply chance modifer aura
    if (Player* modOwner = GetSpellModOwner())
    {
        modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CHANCE_OF_SUCCESS, chance);
    }
 
    return roll_chance_f(chance);
}

◆ isTurning()

bool Unit::isTurning ( ) const

inline

Definition at line 2376 of file Unit.h.

2376{ return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_MASK_TURNING); }

MOVEMENTFLAG_MASK_TURNING

@ MOVEMENTFLAG_MASK_TURNING

Definition: Unit.h:590

◆ IsUnderLastManaUseEffect()

bool Unit::IsUnderLastManaUseEffect ( ) const

Definition at line 17304 of file Unit.cpp.

{
    return  getMSTimeDiff(m_lastManaUse, GameTime::GetGameTimeMS().count()) < 5000;
}

◆ IsUnderWater()

bool Unit::IsUnderWater ( ) const

virtual

Definition at line 4272 of file Unit.cpp.

{
    return GetLiquidData().Status == LIQUID_MAP_UNDER_WATER;
}

◆ IsValidAssistTarget()

bool Unit::IsValidAssistTarget ( Unit const * target ) const

Definition at line 13884 of file Unit.cpp.

{
    return _IsValidAssistTarget(target, nullptr);
}

◆ IsValidAttackTarget()

bool Unit::IsValidAttackTarget ( Unit const * target ) const

Definition at line 13764 of file Unit.cpp.

{
    return _IsValidAttackTarget(target, nullptr);
}

◆ IsVehicle()

bool Unit::IsVehicle ( ) const

inline

Definition at line 1416 of file Unit.h.

1416{ return m_unitTypeMask & UNIT_MASK_VEHICLE; }

◆ IsVendor()

bool Unit::IsVendor ( ) const

inline

Definition at line 1648 of file Unit.h.

1648{ return HasNpcFlag(UNIT_NPC_FLAG_VENDOR); }

◆ IsVisible()

bool Unit::IsVisible ( ) const

inline

Definition at line 2124 of file Unit.h.

2124{ return m_serverSideVisibility.GetValue(SERVERSIDE_VISIBILITY_GM) <= SEC_PLAYER; }

SEC_PLAYER

@ SEC_PLAYER

Definition: Common.h:66

SERVERSIDE_VISIBILITY_GM

@ SERVERSIDE_VISIBILITY_GM

Definition: SharedDefines.h:1245

FlaggedValuesArray32::GetValue

T_VALUES GetValue(FLAG_TYPE flag) const

Definition: Object.h:359

◆ IsWalking()

bool Unit::IsWalking ( ) const

inline

Definition at line 2374 of file Unit.h.

2374{ return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_WALKING); }

MOVEMENTFLAG_WALKING

@ MOVEMENTFLAG_WALKING

Definition: Unit.h:560

◆ IsWithinCombatRange()

bool Unit::IsWithinCombatRange	(	Unit const *	obj,
		float	dist2compare
	)		const

Definition at line 666 of file Unit.cpp.

{
    if (!obj || !IsInMap(obj) || !InSamePhase(obj))
        return false;
 
    float dx = GetPositionX() - obj->GetPositionX();
    float dy = GetPositionY() - obj->GetPositionY();
    float dz = GetPositionZ() - obj->GetPositionZ();
    float distsq = dx * dx + dy * dy + dz * dz;
 
    float sizefactor = GetCombatReach() + obj->GetCombatReach();
    float maxdist = dist2compare + sizefactor;
 
    return distsq < maxdist * maxdist;
}

◆ IsWithinMeleeRange()

bool Unit::IsWithinMeleeRange	(	Unit const *	obj,
		float	dist = `0.f`
	)		const

Definition at line 682 of file Unit.cpp.

{
    if (!obj || !IsInMap(obj) || !InSamePhase(obj))
        return false;
 
    float dx = GetPositionX() - obj->GetPositionX();
    float dy = GetPositionY() - obj->GetPositionY();
    float dz = GetPositionZ() - obj->GetPositionZ();
    float distsq = dx * dx + dy * dy + dz * dz;
 
    float maxdist = dist + GetMeleeRange(obj);
 
    return distsq < maxdist * maxdist;
}

◆ IsWithinRange()

bool Unit::IsWithinRange	(	Unit const *	obj,
		float	dist
	)		const

Definition at line 703 of file Unit.cpp.

{
    if (!obj || !IsInMap(obj) || !InSamePhase(obj))
    {
        return false;
    }
 
    auto dx = GetPositionX() - obj->GetPositionX();
    auto dy = GetPositionY() - obj->GetPositionY();
    auto dz = GetPositionZ() - obj->GetPositionZ();
    auto distsq = dx * dx + dy * dy + dz * dz;
 
    return distsq <= dist * dist;
}

◆ JumpTo() [1/2]

void Unit::JumpTo	(	float	speedXY,
		float	speedZ,
		bool	forward = `true`
	)

Definition at line 19536 of file Unit.cpp.

{
    float angle = forward ? 0 : M_PI;
    if (GetTypeId() == TYPEID_UNIT)
        GetMotionMaster()->MoveJumpTo(angle, speedXY, speedZ);
    else
    {
        float vcos = cos(angle + GetOrientation());
        float vsin = std::sin(angle + GetOrientation());
 
        WorldPacket data(SMSG_MOVE_KNOCK_BACK, (8 + 4 + 4 + 4 + 4 + 4));
        data << GetPackGUID();
        data << uint32(0);                                      // Sequence
        data << float(vcos);                                    // x direction
        data << float(vsin);                                    // y direction
        data << float(speedXY);                                 // Horizontal speed
        data << float(-speedZ);                                 // Z Movement speed (vertical)
 
        ToPlayer()->GetSession()->SendPacket(&data);
    }
}

◆ JumpTo() [2/2]

void Unit::JumpTo	(	WorldObject *	obj,
		float	speedZ
	)

Definition at line 19558 of file Unit.cpp.

{
    float x, y, z;
    obj->GetContactPoint(this, x, y, z);
    float speedXY = GetExactDist2d(x, y) * 10.0f / speedZ;
    GetMotionMaster()->MoveJump(x, y, z, speedXY, speedZ);
}

◆ Kill()

void Unit::Kill	(	Unit *	killer,
		Unit *	victim,
		bool	durabilityLoss = `true`,
		WeaponAttackType	attackType = `BASE_ATTACK`,
		SpellInfo const *	spellProto = `nullptr`,
		Spell const *	spell = `nullptr`
	)

static

Definition at line 17752 of file Unit.cpp.

{
    // Prevent killing unit twice (and giving reward from kill twice)
    if (!victim->GetHealth())
        return;
 
    if (killer && !killer->IsInMap(victim))
        killer = nullptr;
 
    // find player: owner of controlled `this` or `this` itself maybe
    Player* player = killer ? killer->GetCharmerOrOwnerPlayerOrPlayerItself() : nullptr;
    Creature* creature = victim->ToCreature();
 
    bool isRewardAllowed = true;
    if (creature)
    {
        isRewardAllowed = creature->IsDamageEnoughForLootingAndReward();
        if (!isRewardAllowed)
            creature->SetLootRecipient(nullptr);
    }
 
    // pussywizard: remade this if section (player is on the same map
    if (isRewardAllowed && creature)
    {
        Player* lr = creature->GetLootRecipient();
        if (lr && lr->IsInMap(creature))
            player = creature->GetLootRecipient();
        else if (Group* lrg = creature->GetLootRecipientGroup())
            for (GroupReference* itr = lrg->GetFirstMember(); itr != nullptr; itr = itr->next())
                if (Player* member = itr->GetSource())
                    if (member->IsAtLootRewardDistance(creature))
                    {
                        player = member;
                        break;
                    }
    }
 
    // Exploit fix
    if (creature && creature->IsPet() && creature->GetOwnerGUID().IsPlayer())
        isRewardAllowed = false;
 
    // Reward player, his pets, and group/raid members
    // call kill spell proc event (before real die and combat stop to triggering auras removed at death/combat stop)
    if (isRewardAllowed && player && player != victim)
    {
        WorldPacket data(SMSG_PARTYKILLLOG, (8 + 8)); // send event PARTY_KILL
        data << player->GetGUID(); // player with killing blow
        data << victim->GetGUID(); // victim
 
        Player* looter = player;
        Group* group = player->GetGroup();
        bool hasLooterGuid = false;
 
        if (group)
        {
            group->BroadcastPacket(&data, group->GetMemberGroup(player->GetGUID()));
 
            if (creature)
            {
                group->UpdateLooterGuid(creature, true);
                if (group->GetLooterGuid() && group->GetLootMethod() != FREE_FOR_ALL)
                {
                    looter = ObjectAccessor::FindPlayer(group->GetLooterGuid());
                    if (looter)
                    {
                        hasLooterGuid = true;
                        creature->SetLootRecipient(looter);   // update creature loot recipient to the allowed looter.
                    }
                }
            }
        }
        else
        {
            player->SendDirectMessage(&data);
 
            if (creature)
            {
                WorldPacket data2(SMSG_LOOT_LIST, 8 + 1 + 1);
                data2 << creature->GetGUID();
                data2 << uint8(0); // unk1
                data2 << uint8(0); // no group looter
                player->SendMessageToSet(&data2, true);
            }
        }
 
        // Generate loot before updating looter
        if (creature)
        {
            Loot* loot = &creature->loot;
            loot->clear();
 
            if (uint32 lootid = creature->GetCreatureTemplate()->lootid)
                loot->FillLoot(lootid, LootTemplates_Creature, looter, false, false, creature->GetLootMode(), creature);
 
            if (creature->GetLootMode())
                loot->generateMoneyLoot(creature->GetCreatureTemplate()->mingold, creature->GetCreatureTemplate()->maxgold);
 
            if (group)
            {
                if (hasLooterGuid)
                    group->SendLooter(creature, looter);
                else
                    group->SendLooter(creature, nullptr);
 
                // Update round robin looter only if the creature had loot
                if (!creature->loot.empty())
                    group->UpdateLooterGuid(creature);
            }
        }
 
        player->RewardPlayerAndGroupAtKill(victim, false);
    }
 
    // Do KILL and KILLED procs. KILL proc is called only for the unit who landed the killing blow (and its owner - for pets and totems) regardless of who tapped the victim
    if (killer && (killer->IsPet() || killer->IsTotem()))
        if (Unit* owner = killer->GetOwner())
        {
            Unit::ProcDamageAndSpell(owner, victim, PROC_FLAG_KILL, PROC_FLAG_NONE, PROC_EX_NONE, 0, attackType, spellProto, nullptr, -1, spell);
            sScriptMgr->OnCreatureKilledByPet( killer->GetCharmerOrOwnerPlayerOrPlayerItself(), victim->ToCreature());
        }
 
    if (killer != victim && !victim->IsCritter())
        Unit::ProcDamageAndSpell(killer, victim, killer ? PROC_FLAG_KILL : 0, PROC_FLAG_KILLED, PROC_EX_NONE, 0, attackType, spellProto, nullptr, -1, spell);
 
    // Proc auras on death - must be before aura/combat remove
    Unit::ProcDamageAndSpell(victim, nullptr, PROC_FLAG_DEATH, PROC_FLAG_NONE, PROC_EX_NONE, 0, attackType, spellProto, nullptr, -1, spell);
 
    // update get killing blow achievements, must be done before setDeathState to be able to require auras on target
    // and before Spirit of Redemption as it also removes auras
    if (killer)
        if (Player* killerPlayer = killer->GetCharmerOrOwnerPlayerOrPlayerItself())
            killerPlayer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS, 1, 0, victim);
 
    // Spirit of Redemption
    // if talent known but not triggered (check priest class for speedup check)
    bool spiritOfRedemption = false;
    if (victim->GetTypeId() == TYPEID_PLAYER && victim->getClass() == CLASS_PRIEST && !victim->ToPlayer()->HasPlayerFlag(PLAYER_FLAGS_IS_OUT_OF_BOUNDS))
    {
        if (AuraEffect* aurEff = victim->GetAuraEffectDummy(20711))
        {
            // Xinef: aura_spirit_of_redemption is triggered by 27827 shapeshift
            if (victim->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION) || victim->HasAura(27827))
            {
                /*LOG_INFO("misc", "Player ({}) died with spirit of redemption. Killer (Entry: {}, Name: {}), Map: {}, x: {}, y: {}, z: {}",
                    victim->GetGUID().ToString(), killer ? killer->GetEntry() : 1, killer ? killer->GetName() : "", victim->GetMapId(), victim->GetPositionX(),
                    victim->GetPositionY(), victim->GetPositionZ());
 
                ACE_Stack_Trace trace(0, 50);
                LOG_INFO("misc", "TRACE: {}\n\n", trace);*/
            }
            else
            {
                // save value before aura remove
                uint32 ressSpellId = victim->GetUInt32Value(PLAYER_SELF_RES_SPELL);
                if (!ressSpellId)
                    ressSpellId = victim->ToPlayer()->GetResurrectionSpellId();
 
                //Remove all expected to remove at death auras (most important negative case like DoT or periodic triggers)
                victim->RemoveAllAurasOnDeath();
 
                // Stop attacks
                victim->CombatStop();
                victim->getHostileRefMgr().deleteReferences();
 
                // restore for use at real death
                victim->SetUInt32Value(PLAYER_SELF_RES_SPELL, ressSpellId);
 
                // FORM_SPIRITOFREDEMPTION and related auras
                victim->CastSpell(victim, 27827, true, nullptr, aurEff);
                spiritOfRedemption = true;
            }
        }
    }
 
    if (!spiritOfRedemption)
    {
        LOG_DEBUG("entities.unit", "SET JUST_DIED");
        victim->setDeathState(JUST_DIED);
    }
 
    // Inform pets (if any) when player kills target)
    // MUST come after victim->setDeathState(JUST_DIED); or pet next target
    // selection will get stuck on same target and break pet react state
    if (player)
    {
        Pet* pet = player->GetPet();
        if (pet && pet->IsAlive() && pet->isControlled())
            pet->AI()->KilledUnit(victim);
    }
 
    // 10% durability loss on death
    // clean InHateListOf
    if (Player* plrVictim = victim->ToPlayer())
    {
        // remember victim PvP death for corpse type and corpse reclaim delay
        // at original death (not at SpiritOfRedemtionTalent timeout)
        plrVictim->SetPvPDeath(player != nullptr);
 
        // only if not player and not controlled by player pet. And not at BG
        if ((durabilityLoss && !player && !plrVictim->InBattleground()) || (player && sWorld->getBoolConfig(CONFIG_DURABILITY_LOSS_IN_PVP)))
        {
            LOG_DEBUG("entities.unit", "We are dead, losing {} percent durability", sWorld->getRate(RATE_DURABILITY_LOSS_ON_DEATH));
            plrVictim->DurabilityLossAll(sWorld->getRate(RATE_DURABILITY_LOSS_ON_DEATH), false);
            // durability lost message
            plrVictim->SendDurabilityLoss();
        }
        // Call KilledUnit for creatures
        if (killer && killer->GetTypeId() == TYPEID_UNIT && killer->IsAIEnabled)
            killer->ToCreature()->AI()->KilledUnit(victim);
 
        // last damage from non duel opponent or opponent controlled creature
        if (plrVictim->duel)
        {
            plrVictim->duel->Opponent->CombatStopWithPets(true);
            plrVictim->CombatStopWithPets(true);
            plrVictim->DuelComplete(DUEL_INTERRUPTED);
        }
    }
    else                                                // creature died
    {
        LOG_DEBUG("entities.unit", "DealDamageNotPlayer");
 
        if (!creature->IsPet() && creature->GetLootMode() > 0)
        {
            creature->GetThreatMgr().ClearAllThreat();
 
            // must be after setDeathState which resets dynamic flags
            if (!creature->loot.isLooted())
            {
                creature->SetDynamicFlag(UNIT_DYNFLAG_LOOTABLE);
            }
            else
            {
                creature->AllLootRemovedFromCorpse();
            }
        }
 
        // Call KilledUnit for creatures, this needs to be called after the lootable flag is set
        if (killer && killer->GetTypeId() == TYPEID_UNIT && killer->IsAIEnabled)
            killer->ToCreature()->AI()->KilledUnit(victim);
 
        // Call creature just died function
        if (CreatureAI* ai = creature->AI())
        {
            ai->JustDied(killer);
            sScriptMgr->OnUnitDeath(creature, killer);
        }
 
        if (TempSummon* summon = creature->ToTempSummon())
            if (Unit* summoner = summon->GetSummonerUnit())
                if (summoner->ToCreature() && summoner->IsAIEnabled)
                    summoner->ToCreature()->AI()->SummonedCreatureDies(creature, killer);
 
        // Dungeon specific stuff, only applies to players killing creatures
        if (creature->GetInstanceId())
        {
            Map* instanceMap = creature->GetMap();
            //Player* creditedPlayer = GetCharmerOrOwnerPlayerOrPlayerItself();
            // TODO: do instance binding anyway if the charmer/owner is offline
 
            if (instanceMap->IsDungeon() && player)
                if (instanceMap->IsRaidOrHeroicDungeon())
                    if (creature->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_INSTANCE_BIND)
                        instanceMap->ToInstanceMap()->PermBindAllPlayers();
        }
    }
 
    // outdoor pvp things, do these after setting the death state, else the player activity notify won't work... doh...
    // handle player kill only if not suicide (spirit of redemption for example)
    if (player && killer != victim)
    {
        if (OutdoorPvP* pvp = player->GetOutdoorPvP())
            pvp->HandleKill(player, victim);
 
        if (Battlefield* bf = sBattlefieldMgr->GetBattlefieldToZoneId(player->GetZoneId()))
            bf->HandleKill(player, victim);
    }
 
    //if (victim->GetTypeId() == TYPEID_PLAYER)
    //    if (OutdoorPvP* pvp = victim->ToPlayer()->GetOutdoorPvP())
    //        pvp->HandlePlayerActivityChangedpVictim->ToPlayer();
 
    // battleground things (do this at the end, so the death state flag will be properly set to handle in the bg->handlekill)
    if (player)
        if (Battleground* bg = player->GetBattleground())
        {
            if (victim->GetTypeId() == TYPEID_PLAYER)
                bg->HandleKillPlayer(victim->ToPlayer(), player);
            else
                bg->HandleKillUnit(victim->ToCreature(), player);
        }
 
    // achievement stuff
    if (killer && victim->GetTypeId() == TYPEID_PLAYER)
    {
        if (killer->GetTypeId() == TYPEID_UNIT)
            victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE, killer->GetEntry());
        else if (victim != killer && killer->GetTypeId() == TYPEID_PLAYER)
            victim->ToPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER, 1, killer->ToPlayer()->GetTeamId());
    }
 
    // Hook for OnPVPKill Event
    if (killer)
    {
        if (Player* killerPlr = killer->ToPlayer())
        {
            if (Player* killedPlr = victim->ToPlayer())
                sScriptMgr->OnPVPKill(killerPlr, killedPlr);
            else if (Creature* killedCre = victim->ToCreature())
                sScriptMgr->OnCreatureKill(killerPlr, killedCre);
        }
        else if (Creature* killerCre = killer->ToCreature())
        {
            if (Player* killed = victim->ToPlayer())
                sScriptMgr->OnPlayerKilledByCreature(killerCre, killed);
        }
    }
}

◆ KnockbackFrom()

void Unit::KnockbackFrom	(	float	x,
		float	y,
		float	speedXY,
		float	speedZ
	)

Definition at line 19175 of file Unit.cpp.

{
    Player* player = ToPlayer();
    if (!player)
    {
        if (Unit* charmer = GetCharmer())
        {
            player = charmer->ToPlayer();
            if (player && player->m_mover != this)
                player = nullptr;
        }
    }
 
    if (!player)
    {
        GetMotionMaster()->MoveKnockbackFrom(x, y, speedXY, speedZ);
    }
    else
    {
        float vcos, vsin;
        GetSinCos(x, y, vsin, vcos);
 
        WorldPacket data(SMSG_MOVE_KNOCK_BACK, (8 + 4 + 4 + 4 + 4 + 4));
        data << GetPackGUID();
        data << uint32(0);                                      // counter
        data << float(vcos);                                    // x direction
        data << float(vsin);                                    // y direction
        data << float(speedXY);                                 // Horizontal speed
        data << float(-speedZ);                                 // Z Movement speed (vertical)
 
        player->GetSession()->SendPacket(&data);
 
        if (player->HasAuraType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED) || player->HasAuraType(SPELL_AURA_FLY))
            player->SetCanFly(true, true);
 
        sScriptMgr->AnticheatSetSkipOnePacketForASH(player, true);
        player->SetCanKnockback(true);
    }
}

◆ MagicSpellHitResult()

SpellMissInfo Unit::MagicSpellHitResult	(	Unit *	victim,
		SpellInfo const *	spell
	)

Definition at line 3269 of file Unit.cpp.

{
    // Can`t miss on dead target (on skinning for example)
    if (!victim->IsAlive() && victim->GetTypeId() != TYPEID_PLAYER)
        return SPELL_MISS_NONE;
 
    // vehicles cant miss
    if (IsVehicle())
        return SPELL_MISS_NONE;
 
    // Spells with SPELL_ATTR3_ALWAYS_HIT will additionally fully ignore
    // resist and deflect chances
    // xinef: skip all calculations, proof: Toxic Tolerance quest
    if (spellInfo->HasAttribute(SPELL_ATTR3_ALWAYS_HIT))
        return SPELL_MISS_NONE;
 
    if (spellInfo->HasAttribute(SPELL_ATTR7_NO_ATTACK_MISS))
    {
        return SPELL_MISS_NONE;
    }
 
    SpellSchoolMask schoolMask = spellInfo->GetSchoolMask();
    int32 thisLevel = getLevelForTarget(victim);
    if (GetTypeId() == TYPEID_UNIT && ToCreature()->IsTrigger())
        thisLevel = std::max<int32>(thisLevel, spellInfo->SpellLevel);
    int32 levelDiff = int32(victim->getLevelForTarget(this)) - thisLevel;
 
    int32 MISS_CHANCE_MULTIPLIER;
    if (sWorld->getBoolConfig(CONFIG_MISS_CHANCE_MULTIPLIER_ONLY_FOR_PLAYERS) && GetTypeId() != TYPEID_PLAYER) // keep it as it was originally (7 and 11)
    {
        MISS_CHANCE_MULTIPLIER = victim->GetTypeId() == TYPEID_PLAYER ? 7 : 11;
    }
    else
    {
        MISS_CHANCE_MULTIPLIER = sWorld->getRate(
            victim->GetTypeId() == TYPEID_PLAYER
            ? RATE_MISS_CHANCE_MULTIPLIER_TARGET_PLAYER
            : RATE_MISS_CHANCE_MULTIPLIER_TARGET_CREATURE);
    }
 
    // Base hit chance from attacker and victim levels
    int32 modHitChance = levelDiff < 3
            ? 96 - levelDiff
            : 94 - (levelDiff - 2) * MISS_CHANCE_MULTIPLIER;
 
    // Spellmod from SPELLMOD_RESIST_MISS_CHANCE
    if (Player* modOwner = GetSpellModOwner())
        modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_RESIST_MISS_CHANCE, modHitChance);
 
    // Increase from attacker SPELL_AURA_MOD_INCREASES_SPELL_PCT_TO_HIT auras
    modHitChance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_INCREASES_SPELL_PCT_TO_HIT, schoolMask);
 
    // Spells with SPELL_ATTR3_ALWAYS_HIT will ignore target's avoidance effects
    // xinef: imo it should completly ignore all calculations, eg: 14792. Hits 80 level players on blizz without any problems
    //if (!spell->HasAttribute(SPELL_ATTR3_ALWAYS_HIT))
    {
        // Chance hit from victim SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE auras
        modHitChance += victim->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE, schoolMask);
        // Reduce spell hit chance for Area of effect spells from victim SPELL_AURA_MOD_AOE_AVOIDANCE aura
        if (spellInfo->IsAffectingArea())
            modHitChance -= victim->GetTotalAuraModifier(SPELL_AURA_MOD_AOE_AVOIDANCE);
 
        // Decrease hit chance from victim rating bonus
        if (victim->GetTypeId() == TYPEID_PLAYER)
            modHitChance -= int32(victim->ToPlayer()->GetRatingBonusValue(CR_HIT_TAKEN_SPELL));
    }
 
    int32 HitChance = modHitChance * 100;
    // Increase hit chance from attacker SPELL_AURA_MOD_SPELL_HIT_CHANCE and attacker ratings
    // Xinef: Totems should inherit casters ratings?
    if (IsTotem())
    {
        if (Unit* owner = GetOwner())
            HitChance += int32(owner->m_modSpellHitChance * 100.0f);
    }
    else
        HitChance += int32(m_modSpellHitChance * 100.0f);
 
    if (HitChance < 100)
        HitChance = 100;
    else if (HitChance > 10000)
        HitChance = 10000;
 
    int32 tmp = 10000 - HitChance;
 
    int32 rand = irand(1, 10000); // Needs to be  1 to 10000 to avoid the 1/10000 chance to miss on 100% hit rating
 
    if (rand < tmp)
        return SPELL_MISS_MISS;
 
    // Chance resist mechanic (select max value from every mechanic spell effect)
    int32 resist_chance = victim->GetMechanicResistChance(spellInfo) * 100;
    tmp += resist_chance;
 
    // Chance resist debuff
    if (!spellInfo->IsPositive() && !spellInfo->HasAttribute(SPELL_ATTR4_NO_CAST_LOG))
    {
        bool bNegativeAura = true;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            // Xinef: Check if effect exists!
            if (spellInfo->Effects[i].IsEffect() && spellInfo->Effects[i].ApplyAuraName == 0)
            {
                bNegativeAura = false;
                break;
            }
        }
 
        if (bNegativeAura)
        {
            tmp += victim->GetMaxPositiveAuraModifierByMiscValue(SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(spellInfo->Dispel)) * 100;
            tmp += victim->GetMaxNegativeAuraModifierByMiscValue(SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(spellInfo->Dispel)) * 100;
        }
 
        // Players resistance for binary spells
        if (spellInfo->HasAttribute(SPELL_ATTR0_CU_BINARY_SPELL) && (spellInfo->GetSchoolMask() & (SPELL_SCHOOL_MASK_NORMAL | SPELL_SCHOOL_MASK_HOLY)) == 0)
            tmp += int32(Unit::GetEffectiveResistChance(this, spellInfo->GetSchoolMask(), victim) * 10000.0f); // 100 for spell calculations, and 100 for return value percentage
    }
 
    // Roll chance
    if (rand < tmp)
        return SPELL_MISS_RESIST;
 
    // cast by caster in front of victim
    if (!victim->HasUnitState(UNIT_STATE_STUNNED) && (victim->HasInArc(M_PI, this) || victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION)))
    {
        int32 deflect_chance = victim->GetTotalAuraModifier(SPELL_AURA_DEFLECT_SPELLS) * 100;
        tmp += deflect_chance;
        if (rand < tmp)
            return SPELL_MISS_DEFLECT;
    }
 
    return SPELL_MISS_NONE;
}

◆ MeleeDamageBonusDone()

uint32 Unit::MeleeDamageBonusDone	(	Unit *	pVictim,
		uint32	damage,
		WeaponAttackType	attType,
		SpellInfo const *	spellProto = `nullptr`,
		SpellSchoolMask	damageSchoolMask = `SPELL_SCHOOL_MASK_NORMAL`
	)

Definition at line 12978 of file Unit.cpp.

{
    if (!victim || pdamage == 0)
        return 0;
 
    if (GetTypeId() == TYPEID_UNIT)
    {
        // Dancing Rune Weapon...
        if (GetEntry() == 27893)
        {
            if (Unit* owner = GetOwner())
                return owner->MeleeDamageBonusDone(victim, pdamage, attType, spellProto, damageSchoolMask) / 2;
        }
    }
 
    uint32 creatureTypeMask = victim->GetCreatureTypeMask();
 
    // Done fixed damage bonus auras
    int32 DoneFlatBenefit = 0;
 
    // ..done
    AuraEffectList const& mDamageDoneCreature = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_CREATURE);
    for (AuraEffectList::const_iterator i = mDamageDoneCreature.begin(); i != mDamageDoneCreature.end(); ++i)
        if (creatureTypeMask & uint32((*i)->GetMiscValue()))
            DoneFlatBenefit += (*i)->GetAmount();
 
    // ..done
    // SPELL_AURA_MOD_DAMAGE_DONE included in weapon damage
 
    // ..done (base at attack power for marked target and base at attack power for creature type)
    int32 APbonus = 0;
 
    if (attType == RANGED_ATTACK)
    {
        APbonus += victim->GetTotalAuraModifier(SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
 
        // ..done (base at attack power and creature type)
        AuraEffectList const& mCreatureAttackPower = GetAuraEffectsByType(SPELL_AURA_MOD_RANGED_ATTACK_POWER_VERSUS);
        for (AuraEffectList::const_iterator i = mCreatureAttackPower.begin(); i != mCreatureAttackPower.end(); ++i)
            if (creatureTypeMask & uint32((*i)->GetMiscValue()))
                APbonus += (*i)->GetAmount();
    }
    else
    {
        APbonus += victim->GetTotalAuraModifier(SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS);
 
        // ..done (base at attack power and creature type)
        AuraEffectList const& mCreatureAttackPower = GetAuraEffectsByType(SPELL_AURA_MOD_MELEE_ATTACK_POWER_VERSUS);
        for (AuraEffectList::const_iterator i = mCreatureAttackPower.begin(); i != mCreatureAttackPower.end(); ++i)
            if (creatureTypeMask & uint32((*i)->GetMiscValue()))
                APbonus += (*i)->GetAmount();
    }
 
    if (APbonus != 0)                                       // Can be negative
    {
        bool normalized = false;
        if (spellProto)
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
                if (spellProto->Effects[i].Effect == SPELL_EFFECT_NORMALIZED_WEAPON_DMG)
                {
                    normalized = true;
                    break;
                }
        DoneFlatBenefit += int32(APbonus / 14.0f * GetAPMultiplier(attType, normalized));
    }
 
    // Done total percent damage auras
    float DoneTotalMod = 1.0f;
 
    // mods for SPELL_SCHOOL_MASK_NORMAL are already factored in base melee damage calculation
    if (!(damageSchoolMask & SPELL_SCHOOL_MASK_NORMAL))
    {
        // Some spells don't benefit from pct done mods
        AuraEffectList const& mModDamagePercentDone = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
        for (AuraEffectList::const_iterator i = mModDamagePercentDone.begin(); i != mModDamagePercentDone.end(); ++i)
        {
            if (!spellProto || (spellProto->ValidateAttribute6SpellDamageMods(this, *i, false) &&
                sScriptMgr->IsNeedModMeleeDamagePercent(this, *i, DoneTotalMod, spellProto)))
            {
                if (((*i)->GetMiscValue() & damageSchoolMask))
                {
                    if ((*i)->GetSpellInfo()->EquippedItemClass == -1)
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                    else if (!(*i)->GetSpellInfo()->HasAttribute(SPELL_ATTR5_AURA_AFFECTS_NOT_JUST_REQ_EQUIPED_ITEM) && ((*i)->GetSpellInfo()->EquippedItemSubClassMask == 0))
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                    else if (ToPlayer() && ToPlayer()->HasItemFitToSpellRequirements((*i)->GetSpellInfo()))
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                }
            }
        }
    }
 
    AuraEffectList const& mDamageDoneVersus = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS);
    for (AuraEffectList::const_iterator i = mDamageDoneVersus.begin(); i != mDamageDoneVersus.end(); ++i)
        if (creatureTypeMask & uint32((*i)->GetMiscValue()))
            if (!spellProto || spellProto->ValidateAttribute6SpellDamageMods(this, *i, false))
                AddPct(DoneTotalMod, (*i)->GetAmount());
 
    // bonus against aurastate
    AuraEffectList const& mDamageDoneVersusAurastate = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS_AURASTATE);
    for (AuraEffectList::const_iterator i = mDamageDoneVersusAurastate.begin(); i != mDamageDoneVersusAurastate.end(); ++i)
        if (victim->HasAuraState(AuraStateType((*i)->GetMiscValue())))
            if (!spellProto || spellProto->ValidateAttribute6SpellDamageMods(this, *i, false))
                AddPct(DoneTotalMod, (*i)->GetAmount());
 
    // done scripted mod (take it from owner)
    Unit* owner = GetOwner() ? GetOwner() : this;
    AuraEffectList const& mOverrideClassScript = owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
    for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
    {
        if (spellProto && !spellProto->ValidateAttribute6SpellDamageMods(this, *i, false))
            continue;
 
        if (!(*i)->IsAffectedOnSpell(spellProto))
            continue;
 
        switch ((*i)->GetMiscValue())
        {
            // Tundra Stalker
            // Merciless Combat
            case 7277:
                {
                    // Merciless Combat
                    if ((*i)->GetSpellInfo()->SpellIconID == 2656)
                    {
                        if (!victim->HealthAbovePct(35))
                            AddPct(DoneTotalMod, (*i)->GetAmount());
                    }
                    // Tundra Stalker
                    else
                    {
                        // Frost Fever (target debuff)
                        if (victim->HasAura(55095))
                            AddPct(DoneTotalMod, (*i)->GetAmount());
                    }
                    break;
                }
            // Rage of Rivendare
            case 7293:
                {
                    if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DEATHKNIGHT, 0, 0x02000000, 0))
                        AddPct(DoneTotalMod, (*i)->GetSpellInfo()->GetRank() * 2.0f);
                    break;
                }
            // Marked for Death
            case 7598:
            case 7599:
            case 7600:
            case 7601:
            case 7602:
                {
                    if (victim->GetAuraEffect(SPELL_AURA_MOD_STALKED, SPELLFAMILY_HUNTER, 0x400, 0, 0))
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                    break;
                }
            // Dirty Deeds
            case 6427:
            case 6428:
                {
                    if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
                    {
                        // effect 0 has expected value but in negative state
                        int32 bonus = -(*i)->GetBase()->GetEffect(0)->GetAmount();
                        AddPct(DoneTotalMod, bonus);
                    }
                    break;
                }
        }
    }
 
    // Custom scripted damage
    if (spellProto)
        switch (spellProto->SpellFamilyName)
        {
            case SPELLFAMILY_DEATHKNIGHT:
                // Glacier Rot
                if (spellProto->SpellFamilyFlags[0] & 0x2 || spellProto->SpellFamilyFlags[1] & 0x6)
                    if (AuraEffect* aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 196, 0))
                        if (victim->GetDiseasesByCaster(owner->GetGUID()) > 0)
                            AddPct(DoneTotalMod, aurEff->GetAmount());
                break;
        }
 
    // Some spells don't benefit from done mods
    if (spellProto)
        if (spellProto->HasAttribute(SPELL_ATTR3_IGNORE_CASTER_MODIFIERS))
        {
            DoneFlatBenefit = 0;
            DoneTotalMod = 1.0f;
        }
 
    float tmpDamage = float(int32(pdamage) + DoneFlatBenefit) * DoneTotalMod;
 
    // apply spellmod to Done damage
    if (spellProto)
        if (Player* modOwner = GetSpellModOwner())
            modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_DAMAGE, tmpDamage);
 
    // bonus result can be negative
    return uint32(std::max(tmpDamage, 0.0f));
}

◆ MeleeDamageBonusTaken()

uint32 Unit::MeleeDamageBonusTaken	(	Unit *	attacker,
		uint32	pdamage,
		WeaponAttackType	attType,
		SpellInfo const *	spellProto = `nullptr`,
		SpellSchoolMask	damageSchoolMask = `SPELL_SCHOOL_MASK_NORMAL`
	)

Definition at line 13180 of file Unit.cpp.

{
    if (pdamage == 0)
        return 0;
 
    int32 TakenFlatBenefit = 0;
 
    // ..taken
    AuraEffectList const& mDamageTaken = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
    for (AuraEffectList::const_iterator i = mDamageTaken.begin(); i != mDamageTaken.end(); ++i)
        if ((*i)->GetMiscValue() & damageSchoolMask)
            TakenFlatBenefit += (*i)->GetAmount();
 
    if (attType != RANGED_ATTACK)
        TakenFlatBenefit += GetTotalAuraModifier(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN);
    else
        TakenFlatBenefit += GetTotalAuraModifier(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN);
 
    // Taken total percent damage auras
    float TakenTotalMod = 1.0f;
 
    TakenTotalMod *= GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN, damageSchoolMask);
 
    // .. taken pct (special attacks)
    if (spellProto)
    {
        // From caster spells
        AuraEffectList const& mOwnerTaken = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_FROM_CASTER);
        for (AuraEffectList::const_iterator i = mOwnerTaken.begin(); i != mOwnerTaken.end(); ++i)
            if ((*i)->GetCasterGUID() == attacker->GetGUID() && (*i)->IsAffectedOnSpell(spellProto))
                AddPct(TakenTotalMod, (*i)->GetAmount());
 
        // Mod damage from spell mechanic
        uint32 mechanicMask = spellProto->GetAllEffectsMechanicMask();
 
        // Shred, Maul - "Effects which increase Bleed damage also increase Shred damage"
        if (spellProto->SpellFamilyName == SPELLFAMILY_DRUID && spellProto->SpellFamilyFlags[0] & 0x00008800)
            mechanicMask |= (1 << MECHANIC_BLEED);
 
        if (mechanicMask)
        {
            AuraEffectList const& mDamageDoneMechanic = GetAuraEffectsByType(SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
            for (AuraEffectList::const_iterator i = mDamageDoneMechanic.begin(); i != mDamageDoneMechanic.end(); ++i)
                if (mechanicMask & uint32(1 << ((*i)->GetMiscValue())))
                    AddPct(TakenTotalMod, (*i)->GetAmount());
        }
    }
 
    TakenTotalMod = processDummyAuras(TakenTotalMod);
 
    // .. taken pct: class scripts
    /*AuraEffectList const& mclassScritAuras = GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
    for (AuraEffectList::const_iterator i = mclassScritAuras.begin(); i != mclassScritAuras.end(); ++i)
    {
        switch ((*i)->GetMiscValue())
        {
        }
    }*/
 
    if (attType != RANGED_ATTACK)
    {
        AuraEffectList const& mModMeleeDamageTakenPercent = GetAuraEffectsByType(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT);
        for (AuraEffectList::const_iterator i = mModMeleeDamageTakenPercent.begin(); i != mModMeleeDamageTakenPercent.end(); ++i)
            AddPct(TakenTotalMod, (*i)->GetAmount());
    }
    else
    {
        AuraEffectList const& mModRangedDamageTakenPercent = GetAuraEffectsByType(SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT);
        for (AuraEffectList::const_iterator i = mModRangedDamageTakenPercent.begin(); i != mModRangedDamageTakenPercent.end(); ++i)
            AddPct(TakenTotalMod, (*i)->GetAmount());
    }
 
    // No positive taken bonus, custom attr
    if (spellProto)
        if (spellProto->HasAttribute(SPELL_ATTR0_CU_NO_POSITIVE_TAKEN_BONUS) && TakenTotalMod > 1.0f)
        {
            TakenFlatBenefit = 0;
            TakenTotalMod = 1.0f;
        }
 
    // xinef: sanctified wrath talent
    if (TakenTotalMod < 1.0f && attacker->HasAuraType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST))
    {
        float ignoreModifier = 1.0f - TakenTotalMod;
        bool addModifier = false;
        AuraEffectList const& ResIgnoreAuras = attacker->GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
        for (AuraEffectList::const_iterator j = ResIgnoreAuras.begin(); j != ResIgnoreAuras.end(); ++j)
            if ((*j)->GetMiscValue() & damageSchoolMask)
            {
                ApplyPct(ignoreModifier, (*j)->GetAmount());
                addModifier = true;
            }
 
        if (addModifier)
            TakenTotalMod += ignoreModifier;
    }
 
    float tmpDamage = (float(pdamage) + TakenFlatBenefit) * TakenTotalMod;
 
    // bonus result can be negative
    return uint32(std::max(tmpDamage, 0.0f));
}

◆ MeleeSpellHitResult()

SpellMissInfo Unit::MeleeSpellHitResult	(	Unit *	victim,
		SpellInfo const *	spell
	)

Definition at line 3096 of file Unit.cpp.

{
    // Spells with SPELL_ATTR3_ALWAYS_HIT will additionally fully ignore
    // resist and deflect chances
    if (spellInfo->HasAttribute(SPELL_ATTR3_ALWAYS_HIT))
        return SPELL_MISS_NONE;
 
    WeaponAttackType attType = BASE_ATTACK;
 
    // Check damage class instead of attack type to correctly handle judgements
    // - they are meele, but can't be dodged/parried/deflected because of ranged dmg class
    if (spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED)
        attType = RANGED_ATTACK;
 
    int32 attackerWeaponSkill;
    // skill value for these spells (for example judgements) is 5* level
    if (spellInfo->DmgClass == SPELL_DAMAGE_CLASS_RANGED && !spellInfo->IsRangedWeaponSpell())
        attackerWeaponSkill = getLevel() * 5;
    // bonus from skills is 0.04% per skill Diff
    else
        attackerWeaponSkill = int32(GetWeaponSkillValue(attType, victim));
 
    int32 skillDiff = attackerWeaponSkill - int32(victim->GetMaxSkillValueForLevel(this));
 
    uint32 roll = urand (0, 10000);
 
    uint32 missChance = uint32(MeleeSpellMissChance(victim, attType, skillDiff, spellInfo->Id) * 100.0f);
    // Roll miss
    uint32 tmp = missChance;
    if (roll < tmp)
        return SPELL_MISS_MISS;
 
    bool canDodge = !spellInfo->HasAttribute(SPELL_ATTR7_NO_ATTACK_DODGE);
    bool canParry = !spellInfo->HasAttribute(SPELL_ATTR7_NO_ATTACK_PARRY);
    bool canBlock = spellInfo->HasAttribute(SPELL_ATTR3_COMPLETELY_BLOCKED) && !spellInfo->HasAttribute(SPELL_ATTR0_CU_DIRECT_DAMAGE);
 
    // Same spells cannot be parry/dodge
    if (spellInfo->HasAttribute(SPELL_ATTR0_NO_ACTIVE_DEFENSE))
        return SPELL_MISS_NONE;
 
    // Chance resist mechanic
    int32 resist_chance = victim->GetMechanicResistChance(spellInfo) * 100;
    tmp += resist_chance;
    if (roll < tmp)
        return SPELL_MISS_RESIST;
 
    // Ranged attacks can only miss, resist and deflect
    if (attType == RANGED_ATTACK)
    {
        // only if in front
        if (!victim->HasUnitState(UNIT_STATE_STUNNED) && (victim->HasInArc(M_PI, this) || victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION)))
        {
            int32 deflect_chance = victim->GetTotalAuraModifier(SPELL_AURA_DEFLECT_SPELLS) * 100;
            tmp += deflect_chance;
            if (roll < tmp)
                return SPELL_MISS_DEFLECT;
        }
 
        canDodge = false;
        canParry = false;
    }
 
    // Check for attack from behind
    // xinef: if from behind or spell requires cast from behind
    if (!victim->HasInArc(M_PI, this))
    {
        if (!victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION) || spellInfo->HasAttribute(SPELL_ATTR0_CU_REQ_CASTER_BEHIND_TARGET))
        {
            // Can`t dodge from behind in PvP (but its possible in PvE)
            if (victim->GetTypeId() == TYPEID_PLAYER)
            {
                canDodge = false;
            }
 
            // Can`t parry or block
            canParry = false;
            canBlock = false;
        }
    }
 
    // Check creatures flags_extra for disable parry
    if (victim->GetTypeId() == TYPEID_UNIT)
    {
        uint32 flagEx = victim->ToCreature()->GetCreatureTemplate()->flags_extra;
        // Xinef: no dodge flag
        if (flagEx & CREATURE_FLAG_EXTRA_NO_DODGE)
            canDodge = false;
        if (flagEx & CREATURE_FLAG_EXTRA_NO_PARRY)
            canParry = false;
        // Check creatures flags_extra for disable block
        if (flagEx & CREATURE_FLAG_EXTRA_NO_BLOCK)
            canBlock = false;
    }
    // Ignore combat result aura
    AuraEffectList const& ignore = GetAuraEffectsByType(SPELL_AURA_IGNORE_COMBAT_RESULT);
    for (AuraEffectList::const_iterator i = ignore.begin(); i != ignore.end(); ++i)
    {
        if (!(*i)->IsAffectedOnSpell(spellInfo))
            continue;
        switch ((*i)->GetMiscValue())
        {
            case MELEE_HIT_DODGE:
                canDodge = false;
                break;
            case MELEE_HIT_BLOCK:
                canBlock = false;
                break;
            case MELEE_HIT_PARRY:
                canParry = false;
                break;
            default:
                LOG_DEBUG("entities.unit", "Spell {} SPELL_AURA_IGNORE_COMBAT_RESULT has unhandled state {}", (*i)->GetId(), (*i)->GetMiscValue());
                break;
        }
    }
 
    if (canDodge)
    {
        // Roll dodge
        int32 dodgeChance = int32(victim->GetUnitDodgeChance() * 100.0f) - skillDiff * 4;
        // Reduce enemy dodge chance by SPELL_AURA_MOD_COMBAT_RESULT_CHANCE
        dodgeChance += GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_COMBAT_RESULT_CHANCE, VICTIMSTATE_DODGE) * 100;
        dodgeChance = int32(float(dodgeChance) * GetTotalAuraMultiplier(SPELL_AURA_MOD_ENEMY_DODGE));
        // Reduce dodge chance by attacker expertise rating
        if (GetTypeId() == TYPEID_PLAYER)
            dodgeChance -= int32(ToPlayer()->GetExpertiseDodgeOrParryReduction(attType) * 100.0f);
        else
            dodgeChance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
 
        // xinef: cant dodge while casting or while stunned
        if (dodgeChance < 0 || victim->IsNonMeleeSpellCast(false, false, true) || victim->HasUnitState(UNIT_STATE_CONTROLLED))
            dodgeChance = 0;
 
        tmp += dodgeChance;
        if (roll < tmp)
            return SPELL_MISS_DODGE;
    }
 
    if (canParry)
    {
        // Roll parry
        int32 parryChance = int32(victim->GetUnitParryChance() * 100.0f)  - skillDiff * 4;
        // Reduce parry chance by attacker expertise rating
        if (GetTypeId() == TYPEID_PLAYER)
            parryChance -= int32(ToPlayer()->GetExpertiseDodgeOrParryReduction(attType) * 100.0f);
        else
            parryChance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
 
        // xinef: cant parry while casting or while stunned
        if (parryChance < 0 || victim->IsNonMeleeSpellCast(false, false, true) || victim->HasUnitState(UNIT_STATE_CONTROLLED))
            parryChance = 0;
 
        tmp += parryChance;
        if (roll < tmp)
            return SPELL_MISS_PARRY;
    }
 
    if (canBlock)
    {
        int32 blockChance = int32(victim->GetUnitBlockChance() * 100.0f) - skillDiff * 4;
 
        // xinef: cant block while casting or while stunned
        if (blockChance < 0 || victim->IsNonMeleeSpellCast(false, false, true) || victim->HasUnitState(UNIT_STATE_CONTROLLED))
            blockChance = 0;
 
        tmp += blockChance;
        if (roll < tmp)
            return SPELL_MISS_BLOCK;
    }
 
    return SPELL_MISS_NONE;
}

◆ MeleeSpellMissChance()

float Unit::MeleeSpellMissChance	(	Unit const *	victim,
		WeaponAttackType	attType,
		int32	skillDiff,
		uint32	spellId
	)		const

Definition at line 19020 of file Unit.cpp.

{
    SpellInfo const* spellInfo = spellId ? sSpellMgr->GetSpellInfo(spellId) : nullptr;
    if (spellInfo && spellInfo->HasAttribute(SPELL_ATTR7_NO_ATTACK_MISS))
    {
        return 0.0f;
    }
 
    //calculate miss chance
    float missChance = victim->GetUnitMissChance(attType);
 
    // Check if dual wielding, add additional miss penalty - when mainhand has on next swing spell, offhand doesnt suffer penalty
    if (!spellId && (attType != RANGED_ATTACK) && haveOffhandWeapon() && (!m_currentSpells[CURRENT_MELEE_SPELL] || !m_currentSpells[CURRENT_MELEE_SPELL]->IsNextMeleeSwingSpell()))
    {
        missChance += 19;
    }
 
    // bonus from skills is 0.04%
    //miss_chance -= skillDiff * 0.04f;
    int32 diff = -skillDiff;
    if (victim->GetTypeId() == TYPEID_PLAYER)
        missChance += diff > 0 ? diff * 0.04f : diff * 0.02f;
    else
        missChance += diff > 10 ? 1 + (diff - 10) * 0.4f : diff * 0.1f;
 
    // Calculate hit chance
    float hitChance = 100.0f;
 
    // Spellmod from SPELLMOD_RESIST_MISS_CHANCE
    if (spellId)
    {
        if (Player* modOwner = GetSpellModOwner())
            modOwner->ApplySpellMod(spellId, SPELLMOD_RESIST_MISS_CHANCE, hitChance);
    }
 
    missChance += hitChance - 100.0f;
 
    if (attType == RANGED_ATTACK)
        missChance -= m_modRangedHitChance;
    else
        missChance -= m_modMeleeHitChance;
 
    // Limit miss chance from 0 to 60%
    if (missChance < 0.0f)
        return 0.0f;
    if (missChance > 60.0f)
        return 60.0f;
    return missChance;
}

◆ ModifyAuraState()

void Unit::ModifyAuraState	(	AuraStateType	flag,
		bool	apply
	)

Definition at line 10445 of file Unit.cpp.

{
    if (apply)
    {
        if (!HasFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1)))
        {
            SetFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1));
            Unit::AuraMap& tAuras = GetOwnedAuras();
            for (Unit::AuraMap::iterator itr = tAuras.begin(); itr != tAuras.end(); ++itr)
            {
                if( (*itr).second->IsRemoved() )
                    continue;
 
                if( (*itr).second->GetSpellInfo()->CasterAuraState == flag )
                    if( AuraApplication* aurApp = (*itr).second->GetApplicationOfTarget(GetGUID()) )
                        (*itr).second->HandleAllEffects(aurApp, AURA_EFFECT_HANDLE_REAL, true);
            }
        }
    }
    else
    {
        if (HasFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1)))
        {
            RemoveFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1));
 
            if (flag != AURA_STATE_ENRAGE)                  // enrage aura state triggering continues auras
            {
                Unit::AuraMap& tAuras = GetOwnedAuras();
                for (Unit::AuraMap::iterator itr = tAuras.begin(); itr != tAuras.end(); ++itr)
                {
                    if( (*itr).second->GetSpellInfo()->CasterAuraState == flag )
                        if( AuraApplication* aurApp = (*itr).second->GetApplicationOfTarget(GetGUID()) )
                            (*itr).second->HandleAllEffects(aurApp, AURA_EFFECT_HANDLE_REAL, false);
                }
            }
        }
    }
}

◆ ModifyHealth()

int32 Unit::ModifyHealth ( int32 val )

Definition at line 13981 of file Unit.cpp.

{
    int32 gain = 0;
 
    if (dVal == 0)
        return 0;
 
    int32 curHealth = (int32)GetHealth();
 
    int32 val = dVal + curHealth;
    if (val <= 0)
    {
        SetHealth(0);
        return -curHealth;
    }
 
    int32 maxHealth = (int32)GetMaxHealth();
 
    if (val < maxHealth)
    {
        SetHealth(val);
        gain = val - curHealth;
    }
    else if (curHealth != maxHealth)
    {
        SetHealth(maxHealth);
        gain = maxHealth - curHealth;
    }
 
    return gain;
}

◆ ModifyPower()

int32 Unit::ModifyPower	(	Powers	power,
		int32	val,
		bool	withPowerUpdate = `true`
	)

Definition at line 14039 of file Unit.cpp.

{
    if (dVal == 0)
        return 0;
 
    int32 gain = 0;
 
    int32 curPower = (int32)GetPower(power);
 
    int32 val = dVal + curPower;
    if (val <= 0)
    {
        SetPower(power, 0, withPowerUpdate);
        return -curPower;
    }
 
    int32 maxPower = (int32)GetMaxPower(power);
 
    if (val < maxPower)
    {
        SetPower(power, val, withPowerUpdate);
        gain = val - curPower;
    }
    else if (curPower != maxPower)
    {
        SetPower(power, maxPower, withPowerUpdate);
        gain = maxPower - curPower;
    }
 
    return gain;
}

◆ ModifyPowerPct()

int32 Unit::ModifyPowerPct	(	Powers	power,
		float	pct,
		bool	apply = `true`
	)

Definition at line 14072 of file Unit.cpp.

{
    float amount = (float)GetMaxPower(power);
    ApplyPercentModFloatVar(amount, pct, apply);
 
    return ModifyPower(power, (int32)amount - (int32)GetMaxPower(power));
}

◆ ModifyRedirectThreat()

void Unit::ModifyRedirectThreat ( int32 amount )

inline

Definition at line 2341 of file Unit.h.

2341{ _redirectThreatInfo.ModifyThreatPct(amount); }

RedirectThreatInfo::ModifyThreatPct

void ModifyThreatPct(int32 amount)

Definition: Unit.h:962

◆ ModSpellCastTime()

void Unit::ModSpellCastTime	(	SpellInfo const *	spellProto,
		int32 &	castTime,
		Spell *	spell = `nullptr`
	)

Definition at line 14830 of file Unit.cpp.

{
    if (!spellInfo || castTime < 0)
        return;
 
    if (spellInfo->IsChanneled() && spellInfo->HasAura(SPELL_AURA_MOUNTED))
        return;
 
    // called from caster
    if (Player* modOwner = GetSpellModOwner())
        // TODO:(MadAgos) Eventually check and delete the bool argument
        modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_CASTING_TIME, castTime, spell, bool(modOwner != this && !IsPet()));
 
    switch (spellInfo->DmgClass)
    {
        case SPELL_DAMAGE_CLASS_NONE:
            if (spellInfo->AttributesEx5 & SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC) // required double check
                castTime = int32(float(castTime) * GetFloatValue(UNIT_MOD_CAST_SPEED));
            else if (spellInfo->SpellVisual[0] == 3881 && HasAura(67556)) // cooking with Chef Hat.
                castTime = 500;
            break;
        case SPELL_DAMAGE_CLASS_MELEE:
            break; // no known cases
        case SPELL_DAMAGE_CLASS_MAGIC:
            castTime = CanInstantCast() ? 0 : int32(float(castTime) * GetFloatValue(UNIT_MOD_CAST_SPEED));
            break;
        case SPELL_DAMAGE_CLASS_RANGED:
            castTime = int32(float(castTime) * m_modAttackSpeedPct[RANGED_ATTACK]);
            break;
        default:
            break;
    }
}

◆ ModSpellDuration()

int32 Unit::ModSpellDuration	(	SpellInfo const *	spellProto,
		Unit const *	target,
		int32	duration,
		bool	positive,
		uint32	effectMask
	)

Definition at line 14730 of file Unit.cpp.

{
    // don't mod permanent auras duration
    if (duration < 0)
        return duration;
 
    // some auras are not affected by duration modifiers
    if (spellProto->HasAttribute(SPELL_ATTR7_NO_TARGET_DURATION_MOD))
        return duration;
 
    // cut duration only of negative effects
    // xinef: also calculate self casts, spell can be reflected for example
    if (!positive)
    {
        int32 mechanic = spellProto->GetSpellMechanicMaskByEffectMask(effectMask);
 
        int32 durationMod;
        int32 durationMod_always = 0;
        int32 durationMod_not_stack = 0;
 
        for (uint8 i = 1; i <= MECHANIC_ENRAGED; ++i)
        {
            if (!(mechanic & 1 << i))
                continue;
 
            // Xinef: spells affecting movement imparing effects should not reduce duration if disoriented mechanic is present
            if (i == MECHANIC_SNARE && (mechanic & (1 << MECHANIC_DISORIENTED)))
                continue;
 
            // Find total mod value (negative bonus)
            int32 new_durationMod_always = target->GetTotalAuraModifierByMiscValue(SPELL_AURA_MECHANIC_DURATION_MOD, i);
            // Find max mod (negative bonus)
            int32 new_durationMod_not_stack = target->GetMaxNegativeAuraModifierByMiscValue(SPELL_AURA_MECHANIC_DURATION_MOD_NOT_STACK, i);
            // Check if mods applied before were weaker
            if (new_durationMod_always < durationMod_always)
                durationMod_always = new_durationMod_always;
            if (new_durationMod_not_stack < durationMod_not_stack)
                durationMod_not_stack = new_durationMod_not_stack;
        }
 
        // Select strongest negative mod
        if (durationMod_always > durationMod_not_stack)
            durationMod = durationMod_not_stack;
        else
            durationMod = durationMod_always;
 
        if (durationMod != 0)
            AddPct(duration, durationMod);
 
        // there are only negative mods currently
        durationMod_always = target->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_AURA_DURATION_BY_DISPEL, spellProto->Dispel);
        durationMod_not_stack = target->GetMaxNegativeAuraModifierByMiscValue(SPELL_AURA_MOD_AURA_DURATION_BY_DISPEL_NOT_STACK, spellProto->Dispel);
 
        durationMod = 0;
        if (durationMod_always > durationMod_not_stack)
            durationMod += durationMod_not_stack;
        else
            durationMod += durationMod_always;
 
        if (durationMod != 0)
            AddPct(duration, durationMod);
    }
    else
    {
        // else positive mods here, there are no currently
        // when there will be, change GetTotalAuraModifierByMiscValue to GetTotalPositiveAuraModifierByMiscValue
    }
 
    // Glyphs which increase duration of selfcasted buffs
    if (target == this)
    {
        switch (spellProto->SpellFamilyName)
        {
            case SPELLFAMILY_DRUID:
                if (spellProto->SpellFamilyFlags[0] & 0x100)
                {
                    // Glyph of Thorns
                    if (AuraEffect* aurEff = GetAuraEffect(57862, 0))
                        duration += aurEff->GetAmount() * MINUTE * IN_MILLISECONDS;
                }
                break;
            case SPELLFAMILY_PALADIN:
                if ((spellProto->SpellFamilyFlags[0] & 0x00000002) && spellProto->SpellIconID == 298)
                {
                    // Glyph of Blessing of Might
                    if (AuraEffect* aurEff = GetAuraEffect(57958, 0))
                        duration += aurEff->GetAmount() * MINUTE * IN_MILLISECONDS;
                }
                else if ((spellProto->SpellFamilyFlags[0] & 0x00010000) && spellProto->SpellIconID == 306)
                {
                    // Glyph of Blessing of Wisdom
                    if (AuraEffect* aurEff = GetAuraEffect(57979, 0))
                        duration += aurEff->GetAmount() * MINUTE * IN_MILLISECONDS;
                }
                break;
        }
    }
    return std::max(duration, 0);
}

◆ MonsterMoveWithSpeed()

void Unit::MonsterMoveWithSpeed	(	float	x,
		float	y,
		float	z,
		float	speed
	)

Definition at line 547 of file Unit.cpp.

{
    Movement::MoveSplineInit init(this);
    init.MoveTo(x, y, z);
    init.SetVelocity(speed);
    init.Launch();
}

◆ Mount()

void Unit::Mount	(	uint32	mount,
		uint32	vehicleId = `0`,
		uint32	creatureEntry = `0`
	)

Definition at line 13369 of file Unit.cpp.

{
    if (mount)
        SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, mount);
 
    SetUnitFlag(UNIT_FLAG_MOUNT);
 
    if (Player* player = ToPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(player);
 
        // mount as a vehicle
        if (VehicleId)
        {
            if (CreateVehicleKit(VehicleId, creatureEntry))
            {
                GetVehicleKit()->Reset();
 
                // Send others that we now have a vehicle
                WorldPacket data(SMSG_PLAYER_VEHICLE_DATA, GetPackGUID().size() + 4);
                data << GetPackGUID();
                data << uint32(VehicleId);
                SendMessageToSet(&data, true);
 
                data.Initialize(SMSG_ON_CANCEL_EXPECTED_RIDE_VEHICLE_AURA, 0);
                player->GetSession()->SendPacket(&data);
 
                // mounts can also have accessories
                GetVehicleKit()->InstallAllAccessories(false);
            }
        }
 
        // unsummon pet
        Pet* pet = player->GetPet();
        if (pet)
        {
            Battleground* bg = ToPlayer()->GetBattleground();
            // don't unsummon pet in arena but SetFlag UNIT_FLAG_STUNNED to disable pet's interface
            if (bg && bg->isArena())
                pet->SetUnitFlag(UNIT_FLAG_STUNNED);
            else
                player->UnsummonPetTemporaryIfAny();
        }
 
        // xinef: if we have charmed npc, stun him also
        if (Unit* charm = player->GetCharm())
            if (charm->GetTypeId() == TYPEID_UNIT)
                charm->SetUnitFlag(UNIT_FLAG_STUNNED);
 
        WorldPacket data(SMSG_MOVE_SET_COLLISION_HGT, GetPackGUID().size() + 4 + 4);
        data << GetPackGUID();
        data << uint32(GameTime::GetGameTime().count());   // Packet counter
        data << player->GetCollisionHeight();
        player->GetSession()->SendPacket(&data);
    }
 
    RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MOUNT);
}

◆ NearTeleportTo() [1/2]

void Unit::NearTeleportTo	(	float	x,
		float	y,
		float	z,
		float	orientation,
		bool	casting = `false`,
		bool	vehicleTeleport = `false`,
		bool	withPet = `false`,
		bool	removeTransport = `false`
	)

Definition at line 19993 of file Unit.cpp.

{
    DisableSpline();
    if (GetTypeId() == TYPEID_PLAYER)
        ToPlayer()->TeleportTo(GetMapId(), x, y, z, orientation, TELE_TO_NOT_LEAVE_COMBAT | (removeTransport ? 0 : TELE_TO_NOT_LEAVE_TRANSPORT) | TELE_TO_NOT_UNSUMMON_PET | (casting ? TELE_TO_SPELL : 0) | (vehicleTeleport ? TELE_TO_NOT_LEAVE_VEHICLE : 0) | (withPet ? TELE_TO_WITH_PET : 0));
    else
    {
        Position pos = {x, y, z, orientation};
        SendTeleportPacket(pos);
        UpdatePosition(x, y, z, orientation, true);
        UpdateObjectVisibility();
        GetMotionMaster()->ReinitializeMovement();
    }
}

◆ NearTeleportTo() [2/2]

void Unit::NearTeleportTo	(	Position &	pos,
		bool	casting = `false`,
		bool	vehicleTeleport = `false`,
		bool	withPet = `false`,
		bool	removeTransport = `false`
	)

Definition at line 19988 of file Unit.cpp.

{
    NearTeleportTo(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation(), casting, vehicleTeleport, withPet, removeTransport);
}

◆ OutDebugInfo()

void Unit::OutDebugInfo ( ) const

Definition at line 20238 of file Unit.cpp.

{
    LOG_ERROR("entities.unit", "Unit::OutDebugInfo");
    LOG_INFO("entities.unit", "GUID {}, name {}", GetGUID().ToString(), GetName());
    LOG_INFO("entities.unit", "OwnerGUID {}, MinionGUID {}, CharmerGUID {}, CharmedGUID {}",
        GetOwnerGUID().ToString(), GetMinionGUID().ToString(), GetCharmerGUID().ToString(), GetCharmGUID().ToString());
    LOG_INFO("entities.unit", "In world {}, unit type mask {}", (uint32)(IsInWorld() ? 1 : 0), m_unitTypeMask);
    if (IsInWorld())
        LOG_INFO("entities.unit", "Mapid {}", GetMapId());
 
    LOG_INFO("entities.unit", "Summon Slot: ");
    for (uint32 i = 0; i < MAX_SUMMON_SLOT; ++i)
        LOG_INFO("entities.unit", "{}, ", m_SummonSlot[i].ToString());
    LOG_INFO("server.loading", " ");
 
    LOG_INFO("entities.unit", "Controlled List: ");
    for (ControlSet::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
        LOG_INFO("entities.unit", "{}, ", (*itr)->GetGUID().ToString());
    LOG_INFO("server.loading", " ");
 
    LOG_INFO("entities.unit", "Aura List: ");
    for (AuraApplicationMap::const_iterator itr = m_appliedAuras.begin(); itr != m_appliedAuras.end(); ++itr)
        LOG_INFO("entities.unit", "{}, ", itr->first);
    LOG_INFO("server.loading", " ");
 
    if (IsVehicle())
    {
        LOG_INFO("entities.unit", "Passenger List: ");
        for (SeatMap::iterator itr = GetVehicleKit()->Seats.begin(); itr != GetVehicleKit()->Seats.end(); ++itr)
            if (Unit* passenger = ObjectAccessor::GetUnit(*GetVehicleBase(), itr->second.Passenger.Guid))
                LOG_INFO("entities.unit", "{}, ", passenger->GetGUID().ToString());
        LOG_INFO("server.loading", " ");
    }
 
    if (GetVehicle())
        LOG_INFO("entities.unit", "On vehicle {}.", GetVehicleBase()->GetEntry());
}

◆ PauseMovement()

void Unit::PauseMovement	(	uint32	timer = `0`,
		uint8	slot = `0`
	)

virtual

Definition at line 16755 of file Unit.cpp.

{
    if (slot >= MAX_MOTION_SLOT)
        return;
 
    if (MovementGenerator* movementGenerator = GetMotionMaster()->GetMotionSlot(slot))
        movementGenerator->Pause(timer);
 
    StopMoving();
}

◆ PetSpellFail()

void Unit::PetSpellFail	(	SpellInfo const *	spellInfo,
		Unit *	target,
		uint32	result
	)

Definition at line 20426 of file Unit.cpp.

{
    CharmInfo* charmInfo = GetCharmInfo();
    if (!charmInfo || GetTypeId() != TYPEID_UNIT)
        return;
 
    if ((DisableMgr::IsPathfindingEnabled(GetMap()) || result != SPELL_FAILED_LINE_OF_SIGHT) && target)
    {
        if ((result == SPELL_FAILED_LINE_OF_SIGHT || result == SPELL_FAILED_OUT_OF_RANGE) || !ToCreature()->HasReactState(REACT_PASSIVE))
            if (Unit* owner = GetOwner())
            {
                if (spellInfo->IsPositive() && IsFriendlyTo(target))
                {
                    AttackStop();
                    charmInfo->SetIsAtStay(false);
                    charmInfo->SetIsCommandAttack(true);
                    charmInfo->SetIsReturning(false);
                    charmInfo->SetIsFollowing(false);
 
                    GetMotionMaster()->MoveFollow(target, PET_FOLLOW_DIST, rand_norm() * 2 * M_PI);
                }
                else if (owner->IsValidAttackTarget(target))
                {
                    AttackStop();
                    charmInfo->SetIsAtStay(false);
                    charmInfo->SetIsCommandAttack(true);
                    charmInfo->SetIsReturning(false);
                    charmInfo->SetIsFollowing(false);
 
                    if (!ToCreature()->HasReactState(REACT_PASSIVE))
                        ToCreature()->AI()->AttackStart(target);
                    else
                        GetMotionMaster()->MoveChase(target);
                }
            }
 
        // can be extended in future
        if (result == SPELL_FAILED_LINE_OF_SIGHT || result == SPELL_FAILED_OUT_OF_RANGE)
        {
            charmInfo->SetForcedSpell(spellInfo->IsPositive() ? -int32(spellInfo->Id) : spellInfo->Id);
            charmInfo->SetForcedTargetGUID(target->GetGUID());
        }
        else
        {
            charmInfo->SetForcedSpell(0);
            charmInfo->SetForcedTargetGUID(ObjectGuid::Empty);
        }
    }
}

◆ ProcDamageAndSpell()

void Unit::ProcDamageAndSpell	(	Unit *	actor,
		Unit *	victim,
		uint32	procAttacker,
		uint32	procVictim,
		uint32	procEx,
		uint32	amount,
		WeaponAttackType	attType = `BASE_ATTACK`,
		SpellInfo const *	procSpellInfo = `nullptr`,
		SpellInfo const *	procAura = `nullptr`,
		int8	procAuraEffectIndex = `-1`,
		Spell const *	procSpell = `nullptr`,
		DamageInfo *	damageInfo = `nullptr`,
		HealInfo *	healInfo = `nullptr`,
		uint32	procPhase = `2`
	)

static

Definition at line 6278 of file Unit.cpp.

{
    // Not much to do if no flags are set.
    if (procAttacker && actor)
        actor->ProcDamageAndSpellFor(false, victim, procAttacker, procExtra, attType, procSpellInfo, amount, procAura, procAuraEffectIndex, procSpell, damageInfo, healInfo, procPhase);
    // Now go on with a victim's events'n'auras
    // Not much to do if no flags are set or there is no victim
    if (victim && victim->IsAlive() && procVictim)
        victim->ProcDamageAndSpellFor(true, actor, procVictim, procExtra, attType, procSpellInfo, amount, procAura, procAuraEffectIndex, procSpell, damageInfo, healInfo, procPhase);
}

◆ ProcDamageAndSpellFor()

void Unit::ProcDamageAndSpellFor	(	bool	isVictim,
		Unit *	target,
		uint32	procFlag,
		uint32	procExtra,
		WeaponAttackType	attType,
		SpellInfo const *	procSpellInfo,
		uint32	damage,
		SpellInfo const *	procAura = `nullptr`,
		int8	procAuraEffectIndex = `-1`,
		Spell const *	procSpell = `nullptr`,
		DamageInfo *	damageInfo = `nullptr`,
		HealInfo *	healInfo = `nullptr`,
		uint32	procPhase = `2`
	)

Definition at line 16152 of file Unit.cpp.

{
    // Player is loaded now - do not allow passive spell casts to proc
    if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetSession()->PlayerLoading())
        return;
    // For melee/ranged based attack need update skills and set some Aura states if victim present
    if (procFlag & MELEE_BASED_TRIGGER_MASK && target && procPhase == PROC_SPELL_PHASE_HIT)
    {
        // Xinef: Shaman in ghost wolf form cant proc anything melee based
        if (!isVictim && GetShapeshiftForm() == FORM_GHOSTWOLF)
            return;
 
        // Update skills here for players
        // only when you are not fighting other players or their pets/totems (pvp)
        if (IsPlayer() && !target->IsCharmedOwnedByPlayerOrPlayer())
        {
            // On melee based hit/miss/resist/parry/dodge need to update skill (for victim and attacker)
            if (procExtra & (PROC_EX_NORMAL_HIT | PROC_EX_MISS | PROC_EX_RESIST | PROC_EX_PARRY | PROC_EX_DODGE))
            {
                ToPlayer()->UpdateCombatSkills(target, attType, isVictim, procSpell ? procSpell->m_weaponItem : nullptr);
            }
            // Update defence if player is victim and we block - TODO: confirm that blocked attacks only have a chance to increase defence skill
            else if (isVictim && procExtra & (PROC_EX_BLOCK))
            {
                ToPlayer()->UpdateCombatSkills(target, attType, true);
            }
        }
        // If exist crit/parry/dodge/block need update aura state (for victim and attacker)
        if (procExtra & (PROC_EX_CRITICAL_HIT | PROC_EX_PARRY | PROC_EX_DODGE | PROC_EX_BLOCK))
        {
            // for victim
            if (isVictim)
            {
                // if victim and dodge attack
                if (procExtra & PROC_EX_DODGE)
                {
                    // Update AURA_STATE on dodge
                    if (getClass() != CLASS_ROGUE) // skip Rogue Riposte
                    {
                        ModifyAuraState(AURA_STATE_DEFENSE, true);
                        StartReactiveTimer(REACTIVE_DEFENSE);
                    }
                }
                // if victim and parry attack
                if (procExtra & PROC_EX_PARRY)
                {
                    // For Hunters only Counterattack (skip Mongoose bite)
                    if (getClass() == CLASS_HUNTER)
                    {
                        ModifyAuraState(AURA_STATE_HUNTER_PARRY, true);
                        StartReactiveTimer(REACTIVE_HUNTER_PARRY);
                    }
                    else
                    {
                        ModifyAuraState(AURA_STATE_DEFENSE, true);
                        StartReactiveTimer(REACTIVE_DEFENSE);
                    }
                }
                // if and victim block attack
                if (procExtra & PROC_EX_BLOCK)
                {
                    ModifyAuraState(AURA_STATE_DEFENSE, true);
                    StartReactiveTimer(REACTIVE_DEFENSE);
                }
            }
            else // For attacker
            {
                // Overpower on victim dodge
                if (procExtra & PROC_EX_DODGE)
                {
                    if (getClass() == CLASS_WARRIOR)
                    {
                        AddComboPoints(target, 1);
                        StartReactiveTimer(REACTIVE_OVERPOWER);
                    }
                }
 
                // Wolverine Bite
                if ((procExtra & PROC_HIT_CRITICAL) && IsHunterPet())
                {
                    AddComboPoints(target, 1);
                    StartReactiveTimer(REACTIVE_WOLVERINE_BITE);
                }
            }
        }
    }
 
    Unit* actor = isVictim ? target : this;
    Unit* actionTarget = !isVictim ? target : this;
 
    ProcEventInfo eventInfo = ProcEventInfo(actor, actionTarget, target, procFlag, 0, procPhase, procExtra, procSpell, damageInfo, healInfo, procAura, procAuraEffectIndex);
 
    ProcTriggeredList procTriggered;
    // Fill procTriggered list
    for (AuraApplicationMap::const_iterator itr = GetAppliedAuras().begin(); itr != GetAppliedAuras().end(); ++itr)
    {
        // Do not allow auras to proc from effect triggered by itself
        if (procAura && procAura->Id == itr->first)
            continue;
 
        // Xinef: Generic Item Equipment cooldown, -1 is a special marker
        if (itr->second->GetBase()->GetCastItemGUID() && HasSpellItemCooldown(itr->first, uint32(-1)))
            continue;
 
        ProcTriggeredData triggerData(itr->second->GetBase());
        // Defensive procs are active on absorbs (so absorption effects are not a hindrance)
        bool active = damage || (procExtra & PROC_EX_BLOCK && isVictim);
        if (isVictim)
            procExtra &= ~PROC_EX_INTERNAL_REQ_FAMILY;
 
        SpellInfo const* spellProto = itr->second->GetBase()->GetSpellInfo();
 
        // only auras that have trigger spell should proc from fully absorbed damage
        if (procExtra & PROC_EX_ABSORB && isVictim)
            if (damage || spellProto->Effects[EFFECT_0].TriggerSpell || spellProto->Effects[EFFECT_1].TriggerSpell || spellProto->Effects[EFFECT_2].TriggerSpell)
                active = true;
 
        // xinef: fix spell procing from damaging / healing casts if spell has DoT / HoT effect only
        // only player spells are taken into account
        if (!active && !isVictim && !(procFlag & PROC_FLAG_DONE_PERIODIC) && procSpellInfo && procSpellInfo->SpellFamilyName && (procSpellInfo->HasAura(SPELL_AURA_PERIODIC_DAMAGE) || procSpellInfo->HasAura(SPELL_AURA_PERIODIC_HEAL)))
            active = true;
 
        // AuraScript Hook
        if (!triggerData.aura->CallScriptCheckProcHandlers(itr->second, eventInfo))
        {
            continue;
        }
 
        bool isTriggeredAtSpellProcEvent = IsTriggeredAtSpellProcEvent(target, triggerData.aura, attType, isVictim, active, triggerData.spellProcEvent, eventInfo);
 
        // AuraScript Hook
        triggerData.aura->CallScriptCheckAfterProcHandlers(itr->second, eventInfo);
 
        if (!isTriggeredAtSpellProcEvent)
        {
            continue;
        }
 
        // do checks using conditions table
        ConditionList conditions = sConditionMgr->GetConditionsForNotGroupedEntry(CONDITION_SOURCE_TYPE_SPELL_PROC, spellProto->Id);
        ConditionSourceInfo condInfo = ConditionSourceInfo(eventInfo.GetActor(), eventInfo.GetActionTarget());
        if (!sConditionMgr->IsObjectMeetToConditions(condInfo, conditions))
        {
            continue;
        }
 
        // Triggered spells not triggering additional spells
        //bool triggered = !spellProto->HasAttribute(SPELL_ATTR3_CAN_PROC_FROM_PROCS) ?
        //    (procExtra & PROC_EX_INTERNAL_TRIGGERED && !(procFlag & PROC_FLAG_DONE_TRAP_ACTIVATION)) : false;
 
        bool hasTriggeredProc = false;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (itr->second->HasEffect(i))
            {
                AuraEffect* aurEff = itr->second->GetBase()->GetEffect(i);
 
                // Skip this auras
                if (isNonTriggerAura[aurEff->GetAuraType()])
                    continue;
 
                // If not trigger by default and spellProcEvent == nullptr - skip
                if (!isTriggerAura[aurEff->GetAuraType()] && !triggerData.spellProcEvent)
                    continue;
 
                switch (aurEff->GetAuraType())
                {
                    case SPELL_AURA_PROC_TRIGGER_SPELL:
                    case SPELL_AURA_MANA_SHIELD:
                    case SPELL_AURA_DUMMY:
                    case SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE:
                        if (uint32 triggerSpellId = aurEff->GetSpellInfo()->Effects[i].TriggerSpell)
                        {
                            triggerData.triggerSpelId[i] = triggerSpellId;
                            hasTriggeredProc = true;
                        }
                        break;
                    default:
                        break;
                }
 
                // Some spells must always trigger
                //if (isAlwaysTriggeredAura[aurEff->GetAuraType()])
                triggerData.effMask |= 1 << i;
            }
        }
 
        if (triggerData.effMask)
        {
            // If there is aura that triggers another proc aura, make sure that the triggered one is going to be proccessed on top of it
            if (hasTriggeredProc)
            {
                bool proccessed = false;
                for (uint8 i = 0; i < EFFECT_ALL; ++i)
                {
                    if (uint32 triggeredSpellId = triggerData.triggerSpelId[i])
                    {
                        auto iter = std::find(procTriggered.begin(), procTriggered.end(), triggeredSpellId);
                        if (iter != procTriggered.end())
                        {
                            std::advance(iter, 1);
                            procTriggered.insert(iter, triggerData);
                            proccessed = true;
                            break;
                        }
                    }
                }
 
                if (!proccessed)
                {
                    procTriggered.push_front(triggerData);
                }
            }
            else
            {
                procTriggered.push_front(triggerData);
            }
        }
    }
 
    // Nothing found
    if (procTriggered.empty())
        return;
 
    // Note: must SetCantProc(false) before return
    if (procExtra & (PROC_EX_INTERNAL_TRIGGERED | PROC_EX_INTERNAL_CANT_PROC))
        SetCantProc(true);
 
    // Handle effects proceed this time
    for (ProcTriggeredList::const_iterator i = procTriggered.begin(); i != procTriggered.end(); ++i)
    {
        // look for aura in auras list, it may be removed while proc event processing
        if (i->aura->IsRemoved())
            continue;
 
        bool useCharges  = i->aura->IsUsingCharges();
        // no more charges to use, prevent proc
        if (useCharges && !i->aura->GetCharges())
            continue;
 
        bool takeCharges = false;
        SpellInfo const* spellInfo = i->aura->GetSpellInfo();
 
        AuraApplication* aurApp = i->aura->GetApplicationOfTarget(GetGUID());
 
        bool prepare = i->aura->CallScriptPrepareProcHandlers(aurApp, eventInfo);
 
        // For players set spell cooldown if need
        uint32 cooldown = 0;
        if (prepare && i->spellProcEvent && i->spellProcEvent->cooldown)
            cooldown = i->spellProcEvent->cooldown;
 
        // Xinef: set cooldown for actual proc
        eventInfo.SetProcCooldown(cooldown);
 
        // Note: must SetCantProc(false) before return
        if (spellInfo->HasAttribute(SPELL_ATTR3_INSTANT_TARGET_PROCS))
            SetCantProc(true);
 
        bool handled = i->aura->CallScriptProcHandlers(aurApp, eventInfo);
 
        // "handled" is needed as long as proc can be handled in multiple places
        if (!handled && HandleAuraProc(target, damage, i->aura, procSpellInfo, procFlag, procExtra, cooldown, &handled))
        {
            uint32 Id = i->aura->GetId();
            LOG_DEBUG("spells.aura", "ProcDamageAndSpell: casting spell {} (triggered with value by {} aura of spell {})", spellInfo->Id, (isVictim ? "a victim's" : "an attacker's"), Id);
            takeCharges = true;
        }
 
        if (!handled)
            for (uint8 effIndex = 0; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
            {
                if (!(i->effMask & (1 << effIndex)))
                    continue;
 
                AuraEffect* triggeredByAura = i->aura->GetEffect(effIndex);
                ASSERT(triggeredByAura);
 
                bool prevented = i->aura->CallScriptEffectProcHandlers(triggeredByAura, aurApp, eventInfo);
                if (prevented)
                {
                    takeCharges = true;
                    continue;
                }
 
                switch (triggeredByAura->GetAuraType())
                {
                    case SPELL_AURA_PROC_TRIGGER_SPELL:
                        {
                            LOG_DEBUG("spells.aura", "ProcDamageAndSpell: casting spell {} (triggered by {} aura of spell {})", spellInfo->Id, (isVictim ? "a victim's" : "an attacker's"), triggeredByAura->GetId());
                            // Don`t drop charge or add cooldown for not started trigger
                            if (HandleProcTriggerSpell(target, damage, triggeredByAura, procSpellInfo, procFlag, procExtra, cooldown, procPhase, eventInfo))
                                takeCharges = true;
                            break;
                        }
                    case SPELL_AURA_PROC_TRIGGER_DAMAGE:
                        {
                            // target has to be valid
                            if (!eventInfo.GetProcTarget())
                                break;
 
                            triggeredByAura->HandleProcTriggerDamageAuraProc(aurApp, eventInfo); // this function is part of the new proc system
                            takeCharges = true;
                            break;
                        }
                    case SPELL_AURA_MANA_SHIELD:
                    case SPELL_AURA_DUMMY:
                        {
                            LOG_DEBUG("spells.aura", "ProcDamageAndSpell: casting spell id {} (triggered by {} dummy aura of spell {})", spellInfo->Id, (isVictim ? "a victim's" : "an attacker's"), triggeredByAura->GetId());
                            if (HandleDummyAuraProc(target, damage, triggeredByAura, procSpellInfo, procFlag, procExtra, cooldown, procSpell))
                                takeCharges = true;
                            break;
                        }
                    case SPELL_AURA_OBS_MOD_POWER:
                    case SPELL_AURA_MOD_SPELL_CRIT_CHANCE:
                    case SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN:
                    case SPELL_AURA_MOD_MELEE_HASTE:
                        LOG_DEBUG("spells.aura", "ProcDamageAndSpell: casting spell id {} (triggered by {} aura of spell {})", spellInfo->Id, isVictim ? "a victim's" : "an attacker's", triggeredByAura->GetId());
                        takeCharges = true;
                        break;
                    case SPELL_AURA_OVERRIDE_CLASS_SCRIPTS:
                        {
                            LOG_DEBUG("spells.aura", "ProcDamageAndSpell: casting spell id {} (triggered by {} aura of spell {})", spellInfo->Id, (isVictim ? "a victim's" : "an attacker's"), triggeredByAura->GetId());
                            if (HandleOverrideClassScriptAuraProc(target, damage, triggeredByAura, procSpellInfo, cooldown))
                                takeCharges = true;
                            break;
                        }
                    case SPELL_AURA_RAID_PROC_FROM_CHARGE_WITH_VALUE:
                        {
                            LOG_DEBUG("spells.aura", "ProcDamageAndSpell: casting mending (triggered by {} dummy aura of spell {})",
                                           (isVictim ? "a victim's" : "an attacker's"), triggeredByAura->GetId());
                            if (damage > 0)
                            {
                                HandleAuraRaidProcFromChargeWithValue(triggeredByAura);
                                takeCharges = true;
                            }
                            break;
                        }
                    case SPELL_AURA_RAID_PROC_FROM_CHARGE:
                        {
                            LOG_DEBUG("spells.aura", "ProcDamageAndSpell: casting mending (triggered by {} dummy aura of spell {})",
                                           (isVictim ? "a victim's" : "an attacker's"), triggeredByAura->GetId());
                            HandleAuraRaidProcFromCharge(triggeredByAura);
                            takeCharges = true;
                            break;
                        }
                    case SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE:
                        {
                            LOG_DEBUG("spells.aura", "ProcDamageAndSpell: casting spell {} (triggered with value by {} aura of spell {})", spellInfo->Id, (isVictim ? "a victim's" : "an attacker's"), triggeredByAura->GetId());
 
                            if (HandleProcTriggerSpell(target, damage, triggeredByAura, procSpellInfo, procFlag, procExtra, cooldown, procPhase, eventInfo))
                                takeCharges = true;
                            break;
                        }
                    case SPELL_AURA_MOD_CASTING_SPEED_NOT_STACK:
                        // Skip melee hits or instant cast spells
                        // xinef: check channeled spells which are affected by haste also
                        if (procSpellInfo && (procSpellInfo->SpellFamilyName || GetTypeId() != TYPEID_PLAYER) &&
                                (procSpellInfo->CalcCastTime() > 0 /*||
                        (procSpell->IsChanneled() && procSpell->GetDuration() > 0 && (HasAuraTypeWithAffectMask(SPELL_AURA_PERIODIC_HASTE, procSpell) || procSpell->HasAttribute(SPELL_ATTR5_SPELL_HASTE_AFFECTS_PERIODIC)))*/))
                            takeCharges = true;
                        break;
                    case SPELL_AURA_REFLECT_SPELLS_SCHOOL:
                        // Skip Melee hits and spells ws wrong school
                        if (procSpellInfo && (triggeredByAura->GetMiscValue() & procSpellInfo->SchoolMask)) // School check
                            takeCharges = true;
                        break;
                    case SPELL_AURA_SPELL_MAGNET:
                        // Skip Melee hits and targets with magnet aura
                        if (procSpellInfo && (triggeredByAura->GetBase()->GetUnitOwner()->ToUnit() == ToUnit())) // Magnet
                            takeCharges = true;
                        break;
                    case SPELL_AURA_MOD_POWER_COST_SCHOOL_PCT:
                    case SPELL_AURA_MOD_POWER_COST_SCHOOL:
                        // Skip melee hits and spells ws wrong school or zero cost
                        if (procSpellInfo &&
                                (procSpellInfo->ManaCost != 0 || procSpellInfo->ManaCostPercentage != 0 || (procSpellInfo->SpellFamilyFlags[1] & 0x2)) && // Cost check, mutilate include
                                (triggeredByAura->GetMiscValue() & procSpellInfo->SchoolMask))          // School check
                            takeCharges = true;
                        break;
                    case SPELL_AURA_MECHANIC_IMMUNITY:
                    case SPELL_AURA_MOD_MECHANIC_RESISTANCE:
                        // Compare mechanic
                        if (procSpellInfo && procSpellInfo->Mechanic == uint32(triggeredByAura->GetMiscValue()))
                            takeCharges = true;
                        break;
                    case SPELL_AURA_MOD_DAMAGE_FROM_CASTER:
                        // Compare casters
                        if (target && triggeredByAura->GetCasterGUID() == target->GetGUID())
                            takeCharges = true;
                        break;
                    // CC Auras which use their amount amount to drop
                    // Are there any more auras which need this?
                    case SPELL_AURA_MOD_CONFUSE:
                    case SPELL_AURA_MOD_FEAR:
                    case SPELL_AURA_MOD_STUN:
                    case SPELL_AURA_MOD_ROOT:
                    case SPELL_AURA_TRANSFORM:
                        {
                            // Spell own direct damage at apply wont break the CC
                            // Xinef: Or when the aura is at full duration (assume that such auras should be added at the end, skipping all damage procs etc.)
                            if (procSpellInfo)
                                if ((!i->aura->IsPermanent() && i->aura->GetDuration() == i->aura->GetMaxDuration()) || procSpellInfo->Id == triggeredByAura->GetId() ||
                                    procSpellInfo->HasAttribute(SPELL_ATTR4_REACTIVE_DAMAGE_PROC))
                                    break;
 
                            // chargeable mods are breaking on hit
                            if (useCharges)
                                takeCharges = true;
                            else if (triggeredByAura->GetAmount()) // aura must have amount
                            {
                                int32 damageLeft = triggeredByAura->GetAmount();
                                // No damage left
                                if (damageLeft < int32(damage))
                                    i->aura->Remove();
                                else
                                    triggeredByAura->SetAmount(damageLeft - damage);
                            }
                            break;
                        }
                    case SPELL_AURA_ABILITY_IGNORE_AURASTATE:
                        if (procSpellInfo && procSpellInfo->Id == 20647) // hack for warriors execute, both dummy and damage spell are affected by ignore aurastate aura
                            break;
                        takeCharges = true;
                        break;
                    case SPELL_AURA_ADD_FLAT_MODIFIER:
                    case SPELL_AURA_ADD_PCT_MODIFIER:
                    {
                        if (SpellModifier* mod = triggeredByAura->GetSpellModifier())
                        {
                            if (mod->op == SPELLMOD_CASTING_TIME && mod->value < 0 && procSpell)
                            {
                                // Skip instant spells
                                if (procSpellInfo->CalcCastTime() <= 0 || (procSpell->GetTriggeredCastFlags() & TRIGGERED_CAST_DIRECTLY) != 0)
                                {
                                    break;
                                }
                            }
                        }
                        takeCharges = true;
                        break;
                    }
                    default:
                        takeCharges = true;
                        break;
                }
                i->aura->CallScriptAfterEffectProcHandlers(triggeredByAura, aurApp, eventInfo);
            }
        // Remove charge (aura can be removed by triggers)
        // xinef: take into account attribute6 of proc spell
        if (prepare && useCharges && takeCharges)
            if (!procSpellInfo || isVictim || !procSpellInfo->HasAttribute(SPELL_ATTR6_DO_NOT_CONSUME_RESOURCES))
                i->aura->DropCharge();
 
        i->aura->CallScriptAfterProcHandlers(aurApp, eventInfo);
 
        if (spellInfo->HasAttribute(SPELL_ATTR3_INSTANT_TARGET_PROCS))
            SetCantProc(false);
    }
 
    // Cleanup proc requirements
    if (procExtra & (PROC_EX_INTERNAL_TRIGGERED | PROC_EX_INTERNAL_CANT_PROC))
        SetCantProc(false);
}

◆ processDummyAuras()

float Unit::processDummyAuras ( float TakenTotalMod ) const

private

Definition at line 11813 of file Unit.cpp.

{
    // note: old code coming from TC, just extracted here to remove the code duplication + solve potential crash
    // see: https://github.com/TrinityCore/TrinityCore/commit/c85710e148d75450baedf6632b9ca6fd40b4148e
 
    // .. taken pct: dummy auras
    auto const& mDummyAuras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
    for (auto i = mDummyAuras.begin(); i != mDummyAuras.end(); ++i)
    {
        if (!(*i) || !(*i)->GetSpellInfo())
        {
            continue;
        }
 
        if (auto spellIconId = (*i)->GetSpellInfo()->SpellIconID)
        {
            switch (spellIconId)
            {
                // Cheat Death
                case 2109:
                    if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
                    {
                        // Patch 2.4.3: The resilience required to reach the 90% damage reduction cap
                        //  is 22.5% critical strike damage reduction, or 444 resilience.
                        // To calculate for 90%, we multiply the 100% by 4 (22.5% * 4 = 90%)
                        float mod = -1.0f * GetMeleeCritDamageReduction(400);
                        AddPct(TakenTotalMod, std::max(mod, float((*i)->GetAmount())));
                    }
                    break;
            }
        }
    }
    return TakenTotalMod;
}

◆ ProcessPositionDataChanged()

void Unit::ProcessPositionDataChanged ( PositionFullTerrainStatus const & data )

overridevirtual

Reimplemented from WorldObject.

Definition at line 4182 of file Unit.cpp.

{
    WorldObject::ProcessPositionDataChanged(data);
    ProcessTerrainStatusUpdate();
}

◆ ProcessTerrainStatusUpdate()

void Unit::ProcessTerrainStatusUpdate ( )

virtual

Reimplemented in Player.

Definition at line 4188 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_UNIT)
        ToCreature()->UpdateMovementFlags();
 
    if (IsFlying() || (!IsControlledByPlayer()))
        return;
 
    LiquidData const& liquidData = GetLiquidData();
 
    // remove appropriate auras if we are swimming/not swimming respectively
    if (liquidData.Status & MAP_LIQUID_STATUS_SWIMMING)
        RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_NOT_ABOVEWATER);
    else
        RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_NOT_UNDERWATER);
 
    // liquid aura handling
    LiquidTypeEntry const* curLiquid = nullptr;
    if ((liquidData.Status & MAP_LIQUID_STATUS_SWIMMING))
        curLiquid = sLiquidTypeStore.LookupEntry(liquidData.Entry);
 
    if (curLiquid != _lastLiquid)
    {
        if (_lastLiquid && _lastLiquid->SpellId)
            RemoveAurasDueToSpell(_lastLiquid->SpellId);
 
        // Set _lastLiquid before casting liquid spell to avoid infinite loops
        _lastLiquid = curLiquid;
 
        Player* player = GetCharmerOrOwnerPlayerOrPlayerItself();
        if (curLiquid && curLiquid->SpellId && (!player || !player->IsGameMaster()))
            CastSpell(this, curLiquid->SpellId, true);
    }
}

◆ ProhibitSpellSchool()

virtual void Unit::ProhibitSpellSchool	(	SpellSchoolMask	,
		uint32
	)

inlinevirtual

Reimplemented in Creature, and Player.

Definition at line 2045 of file Unit.h.

2045{ }

◆ propagateSpeedChange()

void Unit::propagateSpeedChange ( )

inline

-------—End of Pet responses methods-------—

Definition at line 2304 of file Unit.h.

2304{ GetMotionMaster()->propagateSpeedChange(); }

MotionMaster::propagateSpeedChange

void propagateSpeedChange()

Definition: MotionMaster.cpp:794

◆ RemoveAllAttackers()

void Unit::RemoveAllAttackers ( )

Definition at line 10432 of file Unit.cpp.

{
    while (!m_attackers.empty())
    {
        AttackerSet::iterator iter = m_attackers.begin();
        if (!(*iter)->AttackStop())
        {
            LOG_ERROR("entities.unit", "WORLD: Unit has an attacker that isn't attacking it!");
            m_attackers.erase(iter);
        }
    }
}

◆ RemoveAllAuras()

void Unit::RemoveAllAuras ( )

Definition at line 5227 of file Unit.cpp.

{
    // this may be a dead loop if some events on aura remove will continiously apply aura on remove
    // we want to have all auras removed, so use your brain when linking events
    while (!m_appliedAuras.empty() || !m_ownedAuras.empty())
    {
        AuraApplicationMap::iterator aurAppIter;
        for (aurAppIter = m_appliedAuras.begin(); aurAppIter != m_appliedAuras.end();)
            _UnapplyAura(aurAppIter, AURA_REMOVE_BY_DEFAULT);
 
        AuraMap::iterator aurIter;
        for (aurIter = m_ownedAuras.begin(); aurIter != m_ownedAuras.end();)
            RemoveOwnedAura(aurIter);
    }
}

◆ RemoveAllAurasExceptType()

void Unit::RemoveAllAurasExceptType ( AuraType type )

Definition at line 5301 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        Aura const* aura = iter->second->GetBase();
        if (aura->GetSpellInfo()->HasAura(type))
            ++iter;
        else
            _UnapplyAura(iter, AURA_REMOVE_BY_DEFAULT);
    }
 
    for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
    {
        Aura* aura = iter->second;
        if (aura->GetSpellInfo()->HasAura(type))
            ++iter;
        else
            RemoveOwnedAura(iter, AURA_REMOVE_BY_DEFAULT);
    }
}

◆ RemoveAllAurasOnDeath()

void Unit::RemoveAllAurasOnDeath ( )

Definition at line 5257 of file Unit.cpp.

{
    // used just after dieing to remove all visible auras
    // and disable the mods for the passive ones
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        Aura const* aura = iter->second->GetBase();
        if ((!aura->IsPassive() || aura->GetSpellInfo()->HasAttribute(SPELL_ATTR7_DISABLE_AURA_WHILE_DEAD)) && !aura->IsDeathPersistent())
            _UnapplyAura(iter, AURA_REMOVE_BY_DEATH);
        else
            ++iter;
    }
 
    for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
    {
        Aura* aura = iter->second;
        if ((!aura->IsPassive() || aura->GetSpellInfo()->HasAttribute(SPELL_ATTR7_DISABLE_AURA_WHILE_DEAD)) && !aura->IsDeathPersistent())
            RemoveOwnedAura(iter, AURA_REMOVE_BY_DEATH);
        else
            ++iter;
    }
}

◆ RemoveAllAurasRequiringDeadTarget()

void Unit::RemoveAllAurasRequiringDeadTarget ( )

Definition at line 5280 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        Aura const* aura = iter->second->GetBase();
        if (!aura->IsPassive() && aura->GetSpellInfo()->IsRequiringDeadTarget())
            _UnapplyAura(iter, AURA_REMOVE_BY_DEFAULT);
        else
            ++iter;
    }
 
    for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
    {
        Aura* aura = iter->second;
        if (!aura->IsPassive() && aura->GetSpellInfo()->IsRequiringDeadTarget())
            RemoveOwnedAura(iter, AURA_REMOVE_BY_DEFAULT);
        else
            ++iter;
    }
}

◆ RemoveAllControlled()

void Unit::RemoveAllControlled ( bool onDeath = false )

Definition at line 11034 of file Unit.cpp.

{
    // possessed pet and vehicle
    if (GetTypeId() == TYPEID_PLAYER)
        ToPlayer()->StopCastingCharm();
 
    while (!m_Controlled.empty())
    {
        Unit* target = *m_Controlled.begin();
        m_Controlled.erase(m_Controlled.begin());
        if (target->GetCharmerGUID() == GetGUID())
        {
            target->RemoveCharmAuras();
        }
        else if (target->GetOwnerGUID() == GetGUID() && target->IsSummon())
        {
            if (!(onDeath && !IsPlayer() && target->IsGuardian()))
            {
                target->ToTempSummon()->UnSummon();
            }
        }
        else
        {
            LOG_ERROR("entities.unit", "Unit {} is trying to release unit {} which is neither charmed nor owned by it", GetEntry(), target->GetEntry());
        }
    }
}

◆ RemoveAllDynObjects()

void Unit::RemoveAllDynObjects ( )

Definition at line 6063 of file Unit.cpp.

{
    while (!m_dynObj.empty())
        m_dynObj.front()->Remove();
}

◆ RemoveAllGameObjects()

void Unit::RemoveAllGameObjects ( )

Definition at line 6163 of file Unit.cpp.

{
    while(!m_gameObj.empty())
    {
        GameObject* go = ObjectAccessor::GetGameObject(*this, *m_gameObj.begin());
        if(go)
        {
            go->SetOwnerGUID(ObjectGuid::Empty);
            go->SetRespawnTime(0);
            go->Delete();
        }
        m_gameObj.erase(m_gameObj.begin());
    }
}

◆ RemoveAllMinionsByEntry()

void Unit::RemoveAllMinionsByEntry ( uint32 entry )

Definition at line 10811 of file Unit.cpp.

{
    for (Unit::ControlSet::iterator itr = m_Controlled.begin(); itr != m_Controlled.end();)
    {
        Unit* unit = *itr;
        ++itr;
        if (unit->GetEntry() == entry && unit->GetTypeId() == TYPEID_UNIT
                && unit->ToCreature()->IsSummon()) // minion, actually
            unit->ToTempSummon()->UnSummon();
        // i think this is safe because i have never heard that a despawned minion will trigger a same minion
    }
}

◆ RemoveAppliedAuras() [1/2]

void Unit::RemoveAppliedAuras ( std::function< bool(AuraApplication const *)> const & check )

Definition at line 4784 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        if (check(iter->second))
        {
            RemoveAura(iter);
            continue;
        }
        ++iter;
    }
}

◆ RemoveAppliedAuras() [2/2]

void Unit::RemoveAppliedAuras	(	uint32	spellId,
		std::function< bool(AuraApplication const *)> const &	check
	)

Definition at line 4810 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(spellId); iter != m_appliedAuras.upper_bound(spellId);)
    {
        if (check(iter->second))
        {
            RemoveAura(iter);
            continue;
        }
        ++iter;
    }
}

◆ RemoveAreaAurasDueToLeaveWorld()

void Unit::RemoveAreaAurasDueToLeaveWorld ( )

Definition at line 5194 of file Unit.cpp.

{
    // make sure that all area auras not applied on self are removed - prevent access to deleted pointer later
    for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
    {
        Aura* aura = iter->second;
        ++iter;
        Aura::ApplicationMap const& appMap = aura->GetApplicationMap();
        for (Aura::ApplicationMap::const_iterator itr = appMap.begin(); itr != appMap.end();)
        {
            AuraApplication* aurApp = itr->second;
            ++itr;
            Unit* target = aurApp->GetTarget();
            if (target == this)
                continue;
            target->RemoveAura(aurApp);
            // things linked on aura remove may apply new area aura - so start from the beginning
            iter = m_ownedAuras.begin();
        }
    }
 
    // remove area auras owned by others
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        if (iter->second->GetBase()->GetOwner() != this)
        {
            RemoveAura(iter);
        }
        else
            ++iter;
    }
}

◆ RemoveArenaAuras()

void Unit::RemoveArenaAuras ( )

Definition at line 5243 of file Unit.cpp.

{
    // in join, remove positive buffs, on end, remove negative
    // used to remove positive visible auras in arenas
    RemoveAppliedAuras([](AuraApplication const* aurApp)
    {
        Aura const* aura = aurApp->GetBase();
        return (!aura->GetSpellInfo()->HasAttribute(SPELL_ATTR4_ALLOW_ENETRING_ARENA)                          // don't remove stances, shadowform, pally/hunter auras
            && !aura->IsPassive()                                                                              // don't remove passive auras
            && (aurApp->IsPositive() || !aura->GetSpellInfo()->HasAttribute(SPELL_ATTR3_ALLOW_AURA_WHILE_DEAD))) || // not negative death persistent auras
            aura->GetSpellInfo()->HasAttribute(SPELL_ATTR5_REMOVE_ENTERING_ARENA);                             // special marker, always remove
    });
}

◆ RemoveAura() [1/4]

void Unit::RemoveAura	(	Aura *	aur,
		AuraRemoveMode	mode = `AURA_REMOVE_BY_DEFAULT`
	)

Definition at line 4763 of file Unit.cpp.

{
    if (aura->IsRemoved())
        return;
    if (AuraApplication* aurApp = aura->GetApplicationOfTarget(GetGUID()))
        RemoveAura(aurApp, mode);
}

◆ RemoveAura() [2/4]

void Unit::RemoveAura	(	AuraApplication *	aurApp,
		AuraRemoveMode	mode = `AURA_REMOVE_BY_DEFAULT`
	)

Definition at line 4728 of file Unit.cpp.

{
    // we've special situation here, RemoveAura called while during aura removal
    // this kind of call is needed only when aura effect removal handler
    // or event triggered by it expects to remove
    // not yet removed effects of an aura
    if (aurApp->GetRemoveMode())
    {
        // remove remaining effects of an aura
        for (uint8 itr = 0; itr < MAX_SPELL_EFFECTS; ++itr)
        {
            if (aurApp->HasEffect(itr))
                aurApp->_HandleEffect(itr, false);
        }
        return;
    }
    // no need to remove
    if (aurApp->GetBase()->GetApplicationOfTarget(GetGUID()) != aurApp || aurApp->GetBase()->IsRemoved())
        return;
 
    uint32 spellId = aurApp->GetBase()->GetId();
    AuraApplicationMapBoundsNonConst range = m_appliedAuras.equal_range(spellId);
 
    for (AuraApplicationMap::iterator iter = range.first; iter != range.second;)
    {
        if (aurApp == iter->second)
        {
            RemoveAura(iter, mode);
            return;
        }
        else
            ++iter;
    }
}

◆ RemoveAura() [3/4]

void Unit::RemoveAura	(	AuraApplicationMap::iterator &	i,
		AuraRemoveMode	mode = `AURA_REMOVE_BY_DEFAULT`
	)

Definition at line 4696 of file Unit.cpp.

{
    AuraApplication* aurApp = i->second;
    // Do not remove aura which is already being removed
    if (aurApp->GetRemoveMode())
        return;
    Aura* aura = aurApp->GetBase();
    _UnapplyAura(i, mode);
    // Remove aura - for Area and Target auras
    if (aura->GetOwner() == this)
        aura->Remove(mode);
 
    sScriptMgr->OnAuraRemove(this, aurApp, mode);
}

◆ RemoveAura() [4/4]

void Unit::RemoveAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		uint8	reqEffMask = `0`,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

Definition at line 4711 of file Unit.cpp.

{
    AuraApplicationMapBoundsNonConst range = m_appliedAuras.equal_range(spellId);
    for (AuraApplicationMap::iterator iter = range.first; iter != range.second;)
    {
        Aura const* aura = iter->second->GetBase();
        if (((aura->GetEffectMask() & reqEffMask) == reqEffMask)
                && (!caster || aura->GetCasterGUID() == caster))
        {
            RemoveAura(iter, removeMode);
            return;
        }
        else
            ++iter;
    }
}

◆ RemoveAuraFromStack()

void Unit::RemoveAuraFromStack	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

Definition at line 4839 of file Unit.cpp.

{
    AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
    for (AuraMap::iterator iter = range.first; iter != range.second;)
    {
        Aura* aura = iter->second;
        if ((aura->GetType() == UNIT_AURA_TYPE)
                && (!casterGUID || aura->GetCasterGUID() == casterGUID))
        {
            aura->ModStackAmount(-1, removeMode);
            return;
        }
        else
            ++iter;
    }
}

◆ RemoveAurasByShapeShift()

void Unit::RemoveAurasByShapeShift ( )

Definition at line 5178 of file Unit.cpp.

{
    uint32 mechanic_mask = (1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT);
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        Aura const* aura = iter->second->GetBase();
        if ((aura->GetSpellInfo()->GetAllEffectsMechanicMask() & mechanic_mask) &&
            (!aura->GetSpellInfo()->HasAttribute(SPELL_ATTR0_CU_AURA_CC) || (aura->GetSpellInfo()->SpellFamilyName == SPELLFAMILY_WARRIOR && (aura->GetSpellInfo()->SpellFamilyFlags[1] & 0x20))))
        {
            RemoveAura(iter);
            continue;
        }
        ++iter;
    }
}

◆ RemoveAurasByType()

void Unit::RemoveAurasByType	(	AuraType	auraType,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		Aura *	except = `nullptr`,
		bool	negative = `true`,
		bool	positive = `true`
	)

Definition at line 5013 of file Unit.cpp.

{
    // simple check if list is empty
    if (m_modAuras[auraType].empty())
        return;
 
    for (AuraEffectList::iterator iter = m_modAuras[auraType].begin(); iter != m_modAuras[auraType].end();)
    {
        Aura* aura = (*iter)->GetBase();
        AuraApplication* aurApp = aura->GetApplicationOfTarget(GetGUID());
 
        ++iter;
        if (aura != except && (!casterGUID || aura->GetCasterGUID() == casterGUID)
                && ((negative && !aurApp->IsPositive()) || (positive && aurApp->IsPositive())))
        {
            uint32 removedAuras = m_removedAurasCount;
            RemoveAura(aurApp);
            if (m_removedAurasCount > removedAuras + 1)
                iter = m_modAuras[auraType].begin();
        }
    }
}

◆ RemoveAurasDueToItemSpell()

void Unit::RemoveAurasDueToItemSpell	(	uint32	spellId,
		ObjectGuid	castItemGuid
	)

Definition at line 4999 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(spellId); iter != m_appliedAuras.upper_bound(spellId);)
    {
        if (iter->second->GetBase()->GetCastItemGUID() == castItemGuid)
        {
            RemoveAura(iter);
            iter = m_appliedAuras.lower_bound(spellId);
        }
        else
            ++iter;
    }
}

◆ RemoveAurasDueToSpell()

void Unit::RemoveAurasDueToSpell	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		uint8	reqEffMask = `0`,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

Definition at line 4823 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(spellId); iter != m_appliedAuras.upper_bound(spellId);)
    {
        Aura const* aura = iter->second->GetBase();
        if (((aura->GetEffectMask() & reqEffMask) == reqEffMask)
                && (!casterGUID || aura->GetCasterGUID() == casterGUID))
        {
            RemoveAura(iter, removeMode);
            iter = m_appliedAuras.lower_bound(spellId);
        }
        else
            ++iter;
    }
}

◆ RemoveAurasDueToSpellByDispel()

void Unit::RemoveAurasDueToSpellByDispel	(	uint32	spellId,
		uint32	dispellerSpellId,
		ObjectGuid	casterGUID,
		Unit *	dispeller,
		uint8	chargesRemoved = `1`
	)

Definition at line 4856 of file Unit.cpp.

{
    AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
    for (AuraMap::iterator iter = range.first; iter != range.second;)
    {
        Aura* aura = iter->second;
        if (aura->GetCasterGUID() == casterGUID)
        {
            DispelInfo dispelInfo(dispeller, dispellerSpellId, chargesRemoved);
 
            // Call OnDispel hook on AuraScript
            aura->CallScriptDispel(&dispelInfo);
 
            if (aura->GetSpellInfo()->HasAttribute(SPELL_ATTR7_DISPEL_REMOVES_CHARGES))
                aura->ModCharges(-dispelInfo.GetRemovedCharges(), AURA_REMOVE_BY_ENEMY_SPELL);
            else
                aura->ModStackAmount(-dispelInfo.GetRemovedCharges(), AURA_REMOVE_BY_ENEMY_SPELL);
 
            // Call AfterDispel hook on AuraScript
            aura->CallScriptAfterDispel(&dispelInfo);
 
            switch (aura->GetSpellInfo()->SpellFamilyName)
            {
                case SPELLFAMILY_HUNTER:
                    {
                        // Noxious Stings
                        if (aura->GetSpellInfo()->SpellFamilyFlags[1] & 0x1000)
                        {
                            if (Unit* caster = aura->GetCaster())
                            {
                                if (AuraEffect* aureff = caster->GetAuraEffect(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS, SPELLFAMILY_HUNTER, 3521, 1))
                                {
                                    if (Aura* noxious = Aura::TryCreate(aura->GetSpellInfo(), aura->GetEffectMask(), dispeller, caster))
                                    {
                                        noxious->SetDuration(aura->GetDuration() * aureff->GetAmount() / 100);
                                        if (aura->GetUnitOwner() )
                                            if (const std::vector<int32>* spell_triggered = sSpellMgr->GetSpellLinked(-int32(aura->GetId())))
                                                for (std::vector<int32>::const_iterator itr = spell_triggered->begin(); itr != spell_triggered->end(); ++itr)
                                                    aura->GetUnitOwner()->RemoveAurasDueToSpell(*itr);
                                    }
                                }
                            }
                        }
                        break;
                    }
                case SPELLFAMILY_DEATHKNIGHT:
                    {
                        // Icy Clutch, remove with Frost Fever
                        if (aura->GetSpellInfo()->SpellFamilyFlags[1] & 0x4000000)
                        {
                            if (AuraEffect* aureff = GetAuraEffect(SPELL_AURA_MOD_DECREASE_SPEED, SPELLFAMILY_DEATHKNIGHT, 0, 0x40000, 0, casterGUID))
                                RemoveAurasDueToSpell(aureff->GetId());
                        }
                    }
                default:
                    break;
            }
            return;
        }
        else
            ++iter;
    }
}

◆ RemoveAurasDueToSpellBySteal()

void Unit::RemoveAurasDueToSpellBySteal	(	uint32	spellId,
		ObjectGuid	casterGUID,
		Unit *	stealer
	)

Definition at line 4920 of file Unit.cpp.

{
    AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
    for (AuraMap::iterator iter = range.first; iter != range.second;)
    {
        Aura* aura = iter->second;
        if (aura->GetCasterGUID() == casterGUID)
        {
            int32 damage[MAX_SPELL_EFFECTS];
            int32 baseDamage[MAX_SPELL_EFFECTS];
            uint8 effMask = 0;
            uint8 recalculateMask = 0;
            Unit* caster = aura->GetCaster();
            for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (aura->GetEffect(i))
                {
                    baseDamage[i] = aura->GetEffect(i)->GetBaseAmount();
                    damage[i] = aura->GetEffect(i)->GetAmount();
                    effMask |= (1 << i);
                    if (aura->GetEffect(i)->CanBeRecalculated())
                        recalculateMask |= (1 << i);
                }
                else
                {
                    baseDamage[i] = 0;
                    damage[i] = 0;
                }
            }
 
            bool stealCharge = aura->GetSpellInfo()->HasAttribute(SPELL_ATTR7_DISPEL_REMOVES_CHARGES);
            // Cast duration to unsigned to prevent permanent aura's such as Righteous Fury being permanently added to caster
            uint32 dur = std::min(2u * MINUTE * IN_MILLISECONDS, uint32(aura->GetDuration()));
 
            if (Aura* oldAura = stealer->GetAura(aura->GetId(), aura->GetCasterGUID()))
            {
                if (stealCharge)
                    oldAura->ModCharges(1);
                else
                    oldAura->ModStackAmount(1);
                oldAura->SetDuration(int32(dur));
            }
            else
            {
                // single target state must be removed before aura creation to preserve existing single target aura
                if (aura->IsSingleTarget())
                    aura->UnregisterSingleTarget();
 
                // Xinef: if stealer has same aura
                Aura* curAura = stealer->GetAura(aura->GetId());
                if (!curAura || (!curAura->IsPermanent() && curAura->GetDuration() < (int32)dur))
                    if (Aura* newAura = Aura::TryRefreshStackOrCreate(aura->GetSpellInfo(), effMask, stealer, nullptr, &baseDamage[0], nullptr, aura->GetCasterGUID()))
                    {
                        // created aura must not be single target aura,, so stealer won't loose it on recast
                        if (newAura->IsSingleTarget())
                        {
                            newAura->UnregisterSingleTarget();
                            // bring back single target aura status to the old aura
                            aura->SetIsSingleTarget(true);
                            caster->GetSingleCastAuras().push_back(aura);
                        }
                        // FIXME: using aura->GetMaxDuration() maybe not blizzlike but it fixes stealing of spells like Innervate
                        newAura->SetLoadedState(aura->GetMaxDuration(), int32(dur), stealCharge ? 1 : aura->GetCharges(), 1, recalculateMask, &damage[0]);
                        newAura->ApplyForTargets();
                    }
            }
 
            if (stealCharge)
                aura->ModCharges(-1, AURA_REMOVE_BY_ENEMY_SPELL);
            else
                aura->ModStackAmount(-1, AURA_REMOVE_BY_ENEMY_SPELL);
 
            return;
        }
        else
            ++iter;
    }
}

◆ RemoveAurasWithAttribute()

void Unit::RemoveAurasWithAttribute ( uint32 flags )

Definition at line 5036 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        SpellInfo const* spell = iter->second->GetBase()->GetSpellInfo();
        if (spell->Attributes & flags)
            RemoveAura(iter);
        else
            ++iter;
    }
}

◆ RemoveAurasWithFamily()

void Unit::RemoveAurasWithFamily	(	SpellFamilyNames	family,
		uint32	familyFlag1,
		uint32	familyFlag2,
		uint32	familyFlag3,
		ObjectGuid	casterGUID
	)

Definition at line 5119 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        Aura const* aura = iter->second->GetBase();
        if (!casterGUID || aura->GetCasterGUID() == casterGUID)
        {
            SpellInfo const* spell = aura->GetSpellInfo();
            if (spell->SpellFamilyName == uint32(family) && spell->SpellFamilyFlags.HasFlag(familyFlag1, familyFlag2, familyFlag3))
            {
                RemoveAura(iter);
                continue;
            }
        }
        ++iter;
    }
}

◆ RemoveAurasWithInterruptFlags()

void Unit::RemoveAurasWithInterruptFlags	(	uint32	flag,
		uint32	except = `0`,
		bool	isAutoshot = `false`
	)

Definition at line 5084 of file Unit.cpp.

{
    if (!(m_interruptMask & flag))
        return;
 
    // interrupt auras
    for (AuraApplicationList::iterator iter = m_interruptableAuras.begin(); iter != m_interruptableAuras.end();)
    {
        Aura* aura = (*iter)->GetBase();
        ++iter;
        if ((aura->GetSpellInfo()->AuraInterruptFlags & flag) && (!except || aura->GetId() != except))
        {
            uint32 removedAuras = m_removedAurasCount;
            RemoveAura(aura);
            if (m_removedAurasCount > removedAuras + 1)
                iter = m_interruptableAuras.begin();
        }
    }
 
    // interrupt channeled spell
    if (Spell* spell = m_currentSpells[CURRENT_CHANNELED_SPELL])
    {
        if (spell->getState() == SPELL_STATE_CASTING && (spell->m_spellInfo->ChannelInterruptFlags & flag) && spell->m_spellInfo->Id != except)
        {
            // Do not interrupt if auto shot
            if (!(isAutoshot && spell->m_spellInfo->HasAttribute(SPELL_ATTR2_DO_NOT_RESET_COMBAT_TIMERS)))
            {
                InterruptNonMeleeSpells(false, spell->m_spellInfo->Id);
            }
        }
    }
 
    UpdateInterruptMask();
}

◆ RemoveAurasWithMechanic()

void Unit::RemoveAurasWithMechanic	(	uint32	mechanic_mask,
		AuraRemoveMode	removemode = `AURA_REMOVE_BY_DEFAULT`,
		uint32	except = `0`
	)

Definition at line 5161 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        Aura const* aura = iter->second->GetBase();
        if (!except || aura->GetId() != except)
        {
            if (aura->GetSpellInfo()->GetAllEffectsMechanicMask() & mechanic_mask)
            {
                RemoveAura(iter, removemode);
                continue;
            }
        }
        ++iter;
    }
}

◆ RemoveBindSightAuras()

void Unit::RemoveBindSightAuras ( )

Definition at line 11140 of file Unit.cpp.

{
    RemoveAurasByType(SPELL_AURA_BIND_SIGHT);
}

◆ RemoveCharmAuras()

void Unit::RemoveCharmAuras ( )

Definition at line 11145 of file Unit.cpp.

{
    RemoveAurasByType(SPELL_AURA_MOD_CHARM);
    RemoveAurasByType(SPELL_AURA_MOD_POSSESS_PET);
    RemoveAurasByType(SPELL_AURA_MOD_POSSESS);
    RemoveAurasByType(SPELL_AURA_AOE_CHARM);
}

◆ RemoveCharmedBy()

void Unit::RemoveCharmedBy ( Unit * charmer )

Definition at line 18584 of file Unit.cpp.

{
    if (!IsCharmed())
        return;
 
    if (!charmer)
        charmer = GetCharmer();
    if (charmer != GetCharmer()) // one aura overrides another?
    {
        //        LOG_FATAL("entities.unit", "Unit::RemoveCharmedBy: this: {} true charmer: {} false charmer: {}",
        //            GetGUID().ToString(), GetCharmerGUID().ToString(), charmer->GetGUID().ToString());
        //        ABORT();
        return;
    }
 
    CharmType type;
    if (HasUnitState(UNIT_STATE_POSSESSED))
        type = CHARM_TYPE_POSSESS;
    else if (charmer && charmer->IsOnVehicle(this))
        type = CHARM_TYPE_VEHICLE;
    else
        type = CHARM_TYPE_CHARM;
 
    if (_oldFactionId)
    {
        SetFaction(_oldFactionId);
        _oldFactionId = 0;
    }
    else
        RestoreFaction();
 
    CastStop();
    AttackStop();
 
    // xinef: update speed after charming
    UpdateSpeed(MOVE_RUN, false);
 
    // xinef: do not break any controlled motion slot
    if (GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_CONTROLLED) == NULL_MOTION_TYPE)
    {
        StopMoving();
        GetMotionMaster()->MovementExpired();
    }
    // xinef: if we have any controlled movement, clear active and idle only
    else
        GetMotionMaster()->MovementExpiredOnSlot(MOTION_SLOT_ACTIVE, false);
 
    GetMotionMaster()->InitDefault();
 
    // xinef: remove stunned flag if owner was mounted
    if (GetTypeId() == TYPEID_UNIT && !HasUnitState(UNIT_STATE_STUNNED))
        RemoveUnitFlag(UNIT_FLAG_STUNNED);
 
    // If charmer still exists
    if (!charmer)
        return;
 
    ASSERT(type != CHARM_TYPE_POSSESS || charmer->GetTypeId() == TYPEID_PLAYER);
    ASSERT(type != CHARM_TYPE_VEHICLE || (GetTypeId() == TYPEID_UNIT && IsVehicle()));
 
    charmer->SetCharm(this, false);
 
    StopAttackingInvalidTarget();
 
    Player* playerCharmer = charmer->ToPlayer();
    if (playerCharmer)
    {
        switch (type)
        {
            case CHARM_TYPE_VEHICLE:
                playerCharmer->SetClientControl(this, false);
                playerCharmer->SetClientControl(charmer, true); // verified
                RemoveUnitFlag(UNIT_FLAG_POSSESSED);
                ClearUnitState(UNIT_STATE_NO_ENVIRONMENT_UPD);
                break;
            case CHARM_TYPE_POSSESS:
                playerCharmer->SetClientControl(this, false);
                playerCharmer->SetClientControl(charmer, true); // verified
                charmer->RemoveUnitFlag(UNIT_FLAG_DISABLE_MOVE);
                RemoveUnitFlag(UNIT_FLAG_POSSESSED);
                ClearUnitState(UNIT_STATE_POSSESSED);
                ClearUnitState(UNIT_STATE_NO_ENVIRONMENT_UPD);
                break;
            case CHARM_TYPE_CHARM:
                if (GetTypeId() == TYPEID_UNIT && charmer->getClass() == CLASS_WARLOCK)
                {
                    CreatureTemplate const* cinfo = ToCreature()->GetCreatureTemplate();
                    if (cinfo && cinfo->type == CREATURE_TYPE_DEMON)
                    {
                        SetByteValue(UNIT_FIELD_BYTES_0, 1, uint8(cinfo->unit_class));
                        if (GetCharmInfo())
                            GetCharmInfo()->SetPetNumber(0, true);
                        else
                            LOG_ERROR("entities.unit", "Aura::HandleModCharm: target={} has a charm aura but no charm info!", GetGUID().ToString());
                    }
                }
                break;
            default:
                break;
        }
    }
 
    if (Player* player = ToPlayer())
    {
        sScriptMgr->AnticheatSetUnderACKmount(player);
    }
 
    // xinef: restore threat
    for (CharmThreatMap::const_iterator itr = _charmThreatInfo.begin(); itr != _charmThreatInfo.end(); ++itr)
    {
        if (Unit* target = ObjectAccessor::GetUnit(*this, itr->first))
            if (!IsFriendlyTo(target))
                AddThreat(target, itr->second);
    }
 
    _charmThreatInfo.clear();
 
    if (Creature* creature = ToCreature())
    {
        // Vehicle should not attack its passenger after he exists the seat
        if (type != CHARM_TYPE_VEHICLE && charmer->IsAlive() && !charmer->IsFriendlyTo(creature))
            if (Attack(charmer, true))
                GetMotionMaster()->MoveChase(charmer);
 
        // Creature will restore its old AI on next update
        if (creature->AI())
            creature->AI()->OnCharmed(false);
 
        // Xinef: Remove movement flag flying
        RemoveUnitMovementFlag(MOVEMENTFLAG_FLYING);
    }
    else
        ToPlayer()->SetClientControl(this, true); // verified
 
    // a guardian should always have charminfo
    if (playerCharmer && this != charmer->GetFirstControlled())
        playerCharmer->SendRemoveControlBar();
 
    // xinef: Always delete charm info (restores react state)
    if (GetTypeId() == TYPEID_PLAYER || (GetTypeId() == TYPEID_UNIT && !ToCreature()->IsGuardian()))
        DeleteCharmInfo();
}

◆ RemoveComboPointHolder()

void Unit::RemoveComboPointHolder ( Unit * unit )

inline

Definition at line 2295 of file Unit.h.

2295{ m_ComboPointHolders.erase(unit); }

◆ RemoveDynObject()

bool Unit::RemoveDynObject ( uint32 spellId )

Definition at line 6041 of file Unit.cpp.

{
    if (m_dynObj.empty())
        return false;
 
    bool result = false;
    for (DynObjectList::iterator i = m_dynObj.begin(); i != m_dynObj.end();)
    {
        DynamicObject* dynObj = *i;
        if (dynObj->GetSpellId() == spellId)
        {
            dynObj->Remove();
            i = m_dynObj.begin();
            result = true;
        }
        else
            ++i;
    }
 
    return result;
}

◆ RemoveEvadeAuras()

void Unit::RemoveEvadeAuras ( )

Definition at line 5345 of file Unit.cpp.

{
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        Aura const* aura = iter->second->GetBase();
        SpellInfo const* spellInfo = aura->GetSpellInfo();
        if (spellInfo->HasAttribute(SPELL_ATTR0_CU_IGNORE_EVADE) || spellInfo->HasAura(SPELL_AURA_CONTROL_VEHICLE) || spellInfo->HasAura(SPELL_AURA_CLONE_CASTER) || (aura->IsPassive() && GetOwnerGUID().IsPlayer()))
            ++iter;
        else
            _UnapplyAura(iter, AURA_REMOVE_BY_DEFAULT);
    }
 
    for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
    {
        Aura* aura = iter->second;
        SpellInfo const* spellInfo = aura->GetSpellInfo();
        if (spellInfo->HasAttribute(SPELL_ATTR0_CU_IGNORE_EVADE) || spellInfo->HasAura(SPELL_AURA_CONTROL_VEHICLE) || spellInfo->HasAura(SPELL_AURA_CLONE_CASTER) || (aura->IsPassive() && GetOwnerGUID().IsPlayer()))
            ++iter;
        else
            RemoveOwnedAura(iter, AURA_REMOVE_BY_DEFAULT);
    }
}

◆ RemoveExtraUnitMovementFlag()

void Unit::RemoveExtraUnitMovementFlag ( uint16 f )

inline

Definition at line 2274 of file Unit.h.

2274{ m_movementInfo.flags2 &= ~f; }

◆ removeFollower()

void Unit::removeFollower ( FollowerReference * )

inline

Definition at line 2255 of file Unit.h.

2255{ /* nothing to do yet */ }

◆ RemoveFromWorld()

void Unit::RemoveFromWorld ( )

overridevirtual

Reimplemented from WorldObject.

Definition at line 15533 of file Unit.cpp.

{
    // cleanup
    ASSERT(GetGUID());
 
    if (IsInWorld())
    {
        m_duringRemoveFromWorld = true;
        if (IsVehicle())
            RemoveVehicleKit();
 
        RemoveCharmAuras();
        RemoveBindSightAuras();
        RemoveNotOwnSingleTargetAuras();
 
        RemoveAllGameObjects();
        RemoveAllDynObjects();
 
        ExitVehicle();  // Remove applied auras with SPELL_AURA_CONTROL_VEHICLE
        UnsummonAllTotems();
        RemoveAllControlled();
 
        RemoveAreaAurasDueToLeaveWorld();
 
        if (GetCharmerGUID())
        {
            LOG_FATAL("entities.unit", "Unit {} has charmer guid when removed from world", GetEntry());
            ABORT();
        }
 
        if (Unit* owner = GetOwner())
        {
            if (owner->m_Controlled.find(this) != owner->m_Controlled.end())
            {
                if (HasUnitTypeMask(UNIT_MASK_MINION | UNIT_MASK_GUARDIAN))
                    owner->SetMinion((Minion*)this, false);
                LOG_INFO("entities.unit", "Unit {} is in controlled list of {} when removed from world", GetEntry(), owner->GetEntry());
                //ABORT();
            }
        }
 
        WorldObject::RemoveFromWorld();
        m_duringRemoveFromWorld = false;
    }
}

◆ RemoveGameObject() [1/2]

void Unit::RemoveGameObject	(	GameObject *	gameObj,
		bool	del
	)

Definition at line 6097 of file Unit.cpp.

{
    if (!gameObj || gameObj->GetOwnerGUID() != GetGUID())
        return;
 
    gameObj->SetOwnerGUID(ObjectGuid::Empty);
 
    for (uint8 i = 0; i < MAX_GAMEOBJECT_SLOT; ++i)
    {
        if (m_ObjectSlot[i] == gameObj->GetGUID())
        {
            m_ObjectSlot[i].Clear();
            break;
        }
    }
 
    // GO created by some spell
    if (uint32 spellid = gameObj->GetSpellId())
    {
        RemoveAurasDueToSpell(spellid);
 
        if (GetTypeId() == TYPEID_PLAYER)
        {
            SpellInfo const* createBySpell = sSpellMgr->GetSpellInfo(spellid);
            // Need activate spell use for owner
            if (createBySpell && createBySpell->IsCooldownStartedOnEvent())
                // note: item based cooldowns and cooldown spell mods with charges ignored (unknown existing cases)
                ToPlayer()->SendCooldownEvent(createBySpell);
        }
    }
 
    m_gameObj.remove(gameObj->GetGUID());
 
    if (del)
    {
        gameObj->SetRespawnTime(0);
        gameObj->Delete();
    }
}

◆ RemoveGameObject() [2/2]

void Unit::RemoveGameObject	(	uint32	spellid,
		bool	del
	)

Definition at line 6137 of file Unit.cpp.

{
    if (m_gameObj.empty())
        return;
 
    for (GameObjectList::iterator itr = m_gameObj.begin(); itr != m_gameObj.end();)
    {
        if (GameObject* go = ObjectAccessor::GetGameObject(*this, *itr))
        {
            if (spellid > 0 && go->GetSpellId() != spellid)
            {
                ++itr;
                continue;
            }
 
            go->SetOwnerGUID(ObjectGuid::Empty);
            if(del)
            {
                go->SetRespawnTime(0);
                go->Delete();
            }
        }
        m_gameObj.erase(itr++);
    }
}

◆ removeHatedBy()

void Unit::removeHatedBy ( HostileReference * )

inline

Definition at line 2145 of file Unit.h.

2145{ /* nothing to do yet */ }

◆ RemoveMovementImpairingAuras()

void Unit::RemoveMovementImpairingAuras ( bool withRoot )

Definition at line 5137 of file Unit.cpp.

{
    if (withRoot)
        RemoveAurasWithMechanic(1 << MECHANIC_ROOT);
 
    // Snares
    for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end();)
    {
        Aura const* aura = iter->second->GetBase();
        if (aura->GetSpellInfo()->Mechanic == MECHANIC_SNARE)
        {
            RemoveAura(iter);
            continue;
        }
 
        // Xinef: turn off snare auras by setting amount to 0 :)
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            if (((1 << i) & iter->second->GetEffectMask()) && aura->GetSpellInfo()->Effects[i].Mechanic == MECHANIC_SNARE)
                aura->GetEffect(i)->ChangeAmount(0);
 
        ++iter;
    }
}

◆ RemoveNotOwnSingleTargetAuras()

void Unit::RemoveNotOwnSingleTargetAuras ( )

Definition at line 5048 of file Unit.cpp.

{
    // single target auras from other casters
    // Iterate m_ownedAuras - aura is marked as single target in Unit::AddAura (and pushed to m_ownedAuras).
    // m_appliedAuras will NOT contain the aura before first Unit::Update after adding it to m_ownedAuras.
    // Quickly removing such an aura will lead to it not being unregistered from caster's single cast auras container
    // leading to assertion failures if the aura was cast on a player that can
    // (and is changing map at the point where this function is called).
    // Such situation occurs when player is logging in inside an instance and fails the entry check for any reason.
    // The aura that was loaded from db (indirectly, via linked casts) gets removed before it has a chance
    // to register in m_appliedAuras
    for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
    {
        Aura const* aura = iter->second;
 
        if (aura->GetCasterGUID() != GetGUID() && aura->IsSingleTarget())
            RemoveOwnedAura(iter);
        else
            ++iter;
    }
 
    // single target auras at other targets
    AuraList& scAuras = GetSingleCastAuras();
    for (AuraList::iterator iter = scAuras.begin(); iter != scAuras.end();)
    {
        Aura* aura = *iter;
        if (aura->GetUnitOwner() != this)
        {
            aura->Remove();
            iter = scAuras.begin();
        }
        else
            ++iter;
    }
}

◆ RemoveNpcFlag()

void Unit::RemoveNpcFlag ( NPCFlags flags )

inline

Definition at line 1645 of file Unit.h.

1645{ RemoveFlag(UNIT_NPC_FLAGS, flags); }

◆ RemoveOwnedAura() [1/3]

void Unit::RemoveOwnedAura	(	Aura *	aura,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

Definition at line 4658 of file Unit.cpp.

{
    if (aura->IsRemoved())
        return;
 
    ASSERT(aura->GetOwner() == this);
 
    uint32 spellId = aura->GetId();
    AuraMapBoundsNonConst range = m_ownedAuras.equal_range(spellId);
 
    for (AuraMap::iterator itr = range.first; itr != range.second; ++itr)
    {
        if (itr->second == aura)
        {
            RemoveOwnedAura(itr, removeMode);
            return;
        }
    }
 
    ABORT();
}

◆ RemoveOwnedAura() [2/3]

void Unit::RemoveOwnedAura	(	AuraMap::iterator &	i,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

Definition at line 4625 of file Unit.cpp.

{
    Aura* aura = i->second;
    ASSERT(!aura->IsRemoved());
 
    // if unit currently update aura list then make safe update iterator shift to next
    if (m_auraUpdateIterator == i && m_auraUpdateIterator != m_ownedAuras.end())
        ++m_auraUpdateIterator;
 
    m_ownedAuras.erase(i);
    m_removedAuras.push_back(aura);
 
    // Unregister single target aura
    if (aura->IsSingleTarget())
        aura->UnregisterSingleTarget();
 
    aura->_Remove(removeMode);
 
    i = m_ownedAuras.begin();
}

◆ RemoveOwnedAura() [3/3]

void Unit::RemoveOwnedAura	(	uint32	spellId,
		ObjectGuid	casterGUID = `ObjectGuid::Empty`,
		uint8	reqEffMask = `0`,
		AuraRemoveMode	removeMode = `AURA_REMOVE_BY_DEFAULT`
	)

Definition at line 4646 of file Unit.cpp.

{
    for (AuraMap::iterator itr = m_ownedAuras.lower_bound(spellId); itr != m_ownedAuras.upper_bound(spellId);)
        if (((itr->second->GetEffectMask() & reqEffMask) == reqEffMask) && (!casterGUID || itr->second->GetCasterGUID() == casterGUID))
        {
            RemoveOwnedAura(itr, removeMode);
            itr = m_ownedAuras.lower_bound(spellId);
        }
        else
            ++itr;
}

◆ RemoveOwnedAuras() [1/2]

void Unit::RemoveOwnedAuras ( std::function< bool(Aura const *)> const & check )

Definition at line 4771 of file Unit.cpp.

{
    for (AuraMap::iterator iter = m_ownedAuras.begin(); iter != m_ownedAuras.end();)
    {
        if (check(iter->second))
        {
            RemoveOwnedAura(iter);
            continue;
        }
        ++iter;
    }
}

◆ RemoveOwnedAuras() [2/2]

void Unit::RemoveOwnedAuras	(	uint32	spellId,
		std::function< bool(Aura const *)> const &	check
	)

Definition at line 4797 of file Unit.cpp.

{
    for (AuraMap::iterator iter = m_ownedAuras.lower_bound(spellId); iter != m_ownedAuras.upper_bound(spellId);)
    {
        if (check(iter->second))
        {
            RemoveOwnedAura(iter);
            continue;
        }
        ++iter;
    }
}

◆ RemovePetAura()

void Unit::RemovePetAura ( PetAura const * petSpell )

Definition at line 17359 of file Unit.cpp.

{
    if (GetTypeId() != TYPEID_PLAYER)
        return;
 
    m_petAuras.erase(petSpell);
    if (Pet* pet = ToPlayer()->GetPet())
        pet->RemoveAurasDueToSpell(petSpell->GetAura(pet->GetEntry()));
    if (Unit* charm = GetCharm())
        charm->RemoveAurasDueToSpell(petSpell->GetAura(charm->GetEntry()));
}

◆ RemovePlayerFromVision()

void Unit::RemovePlayerFromVision ( Player * player )

Definition at line 11129 of file Unit.cpp.

{
    m_sharedVision.remove(player);
    player->m_isInSharedVisionOf.erase(this);
    if (m_sharedVision.empty())
    {
        setActive(false);
        SetWorldObject(false);
    }
}

◆ RemovePointedBy()

void Unit::RemovePointedBy ( SafeUnitPointer * sup )

inline

Definition at line 2401 of file Unit.h.

2401{ SafeUnitPointerSet.erase(sup); }

◆ RemoveStandFlags()

void Unit::RemoveStandFlags ( uint8 flags )

inline

Definition at line 1538 of file Unit.h.

1538{ RemoveByteFlag(UNIT_FIELD_BYTES_1, UNIT_BYTES_1_OFFSET_VIS_FLAG, flags); }

UNIT_BYTES_1_OFFSET_VIS_FLAG

@ UNIT_BYTES_1_OFFSET_VIS_FLAG

Definition: Unit.h:46

Object::RemoveByteFlag

void RemoveByteFlag(uint16 index, uint8 offset, uint8 newFlag)

Definition: Object.cpp:930

◆ RemoveUnitFlag()

void Unit::RemoveUnitFlag ( UnitFlags flags )

inline

Definition at line 1480 of file Unit.h.

1480{ RemoveFlag(UNIT_FIELD_FLAGS, flags); }

◆ RemoveUnitFlag2()

void Unit::RemoveUnitFlag2 ( UnitFlags2 flags )

inline

Definition at line 1486 of file Unit.h.

1486{ RemoveFlag(UNIT_FIELD_FLAGS_2, flags); }

◆ RemoveUnitMovementFlag()

void Unit::RemoveUnitMovementFlag ( uint32 f )

inline

Definition at line 2268 of file Unit.h.

2268{ m_movementInfo.flags &= ~f; }

◆ RemoveVehicleKit()

void Unit::RemoveVehicleKit ( )

Definition at line 18759 of file Unit.cpp.

{
    if (!m_vehicleKit)
        return;
 
    m_vehicleKit->Uninstall();
    delete m_vehicleKit;
 
    m_vehicleKit = nullptr;
 
    m_updateFlag &= ~UPDATEFLAG_VEHICLE;
    m_unitTypeMask &= ~UNIT_MASK_VEHICLE;
    RemoveNpcFlag(UNIT_NPC_FLAG_SPELLCLICK | UNIT_NPC_FLAG_PLAYER_VEHICLE);
}

◆ RemoveVisibleAura()

void Unit::RemoveVisibleAura ( uint8 slot )

inline

Definition at line 2157 of file Unit.h.

2157{ m_visibleAuras.erase(slot); UpdateAuraForGroup(slot);}

Unit::UpdateAuraForGroup

void UpdateAuraForGroup(uint8 slot)

Definition: Unit.cpp:17230

◆ ReplaceAllDynamicFlags()

void Unit::ReplaceAllDynamicFlags ( uint32 flag )

inlineoverridevirtual

Reimplemented from Object.

Definition at line 1326 of file Unit.h.

1326{ SetUInt32Value(UNIT_DYNAMIC_FLAGS, flag); }

◆ ReplaceAllNpcFlags()

void Unit::ReplaceAllNpcFlags ( NPCFlags flags )

inline

Definition at line 1646 of file Unit.h.

1646{ SetUInt32Value(UNIT_NPC_FLAGS, flags); }

◆ ReplaceAllUnitFlags()

void Unit::ReplaceAllUnitFlags ( UnitFlags flags )

inline

Definition at line 1481 of file Unit.h.

1481{ SetUInt32Value(UNIT_FIELD_FLAGS, flags); }

◆ ReplaceAllUnitFlags2()

void Unit::ReplaceAllUnitFlags2 ( UnitFlags2 flags )

inline

Definition at line 1487 of file Unit.h.

1487{ SetUInt32Value(UNIT_FIELD_FLAGS_2, flags); }

◆ resetAttackTimer()

void Unit::resetAttackTimer ( WeaponAttackType type = BASE_ATTACK )

Definition at line 660 of file Unit.cpp.

{
    int32 time = int32(GetAttackTime(type) * m_modAttackSpeedPct[type]);
    m_attackTimer[type] = std::min(m_attackTimer[type] + time, time);
}

◆ ResetRedirectThreat()

void Unit::ResetRedirectThreat ( )

inline

Definition at line 2340 of file Unit.h.

2340{ SetRedirectThreat(ObjectGuid::Empty, 0); }

Unit::SetRedirectThreat

void SetRedirectThreat(ObjectGuid guid, uint32 pct)

Definition: Unit.h:2339

◆ RestoreDisplayId()

void Unit::RestoreDisplayId ( )

Definition at line 16850 of file Unit.cpp.

{
    AuraEffect* handledAura = nullptr;
    AuraEffect* handledAuraForced = nullptr;
    // try to receive model from transform auras
    Unit::AuraEffectList const& transforms = GetAuraEffectsByType(SPELL_AURA_TRANSFORM);
    if (!transforms.empty())
    {
        // iterate over already applied transform auras - from newest to oldest
        for (Unit::AuraEffectList::const_reverse_iterator i = transforms.rbegin(); i != transforms.rend(); ++i)
        {
            if (AuraApplication const* aurApp = (*i)->GetBase()->GetApplicationOfTarget(GetGUID()))
            {
                if (!handledAura)
                    handledAura = (*i);
                // xinef: prefer negative/forced auras
                if ((*i)->GetSpellInfo()->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES) || !aurApp->IsPositive())
                {
                    handledAuraForced = (*i);
                    break;
                }
            }
        }
    }
 
    // Xinef: include clone auras (eg mirror images)
    if (!handledAuraForced && !handledAura)
    {
        Unit::AuraEffectList const& cloneAuras = GetAuraEffectsByType(SPELL_AURA_CLONE_CASTER);
        if (!cloneAuras.empty())
            for (Unit::AuraEffectList::const_iterator i = cloneAuras.begin(); i != cloneAuras.end(); ++i)
                handledAura = *i;
    }
 
    // xinef: order of execution is important!
    // first forced transform auras, then shapeshifts, then normal transform
    // transform aura was found
    if (handledAuraForced)
        handledAuraForced->HandleEffect(this, AURA_EFFECT_HANDLE_SEND_FOR_CLIENT, true);
    // we've found shapeshift
    else if (uint32 modelId = GetModelForForm(GetShapeshiftForm()))
        SetDisplayId(modelId);
    else if (handledAura)
        handledAura->HandleEffect(this, AURA_EFFECT_HANDLE_SEND_FOR_CLIENT, true);
    // no auras found - set modelid to default
    else
        SetDisplayId(GetNativeDisplayId());
}

◆ RestoreFaction()

void Unit::RestoreFaction ( )

Definition at line 18727 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_PLAYER)
        ToPlayer()->SetFactionForRace(getRace());
    else
    {
        if (HasUnitTypeMask(UNIT_MASK_MINION))
        {
            if (Unit* owner = GetOwner())
            {
                SetFaction(owner->GetFaction());
                return;
            }
        }
 
        if (CreatureTemplate const* cinfo = ToCreature()->GetCreatureTemplate())  // normal creature
            SetFaction(cinfo->faction);
    }
}

◆ ResumeMovement()

void Unit::ResumeMovement	(	uint32	timer = `0`,
		uint8	slot = `0`
	)

Definition at line 16766 of file Unit.cpp.

{
    if (slot >= MAX_MOTION_SLOT)
        return;
 
    if (MovementGenerator* movementGenerator = GetMotionMaster()->GetMotionSlot(slot))
        movementGenerator->Resume(timer);
}

◆ RewardRage()

void Unit::RewardRage	(	uint32	damage,
		uint32	weaponSpeedHitFactor,
		bool	attacker
	)

Definition at line 20142 of file Unit.cpp.

{
    float addRage;
 
    float rageconversion = ((0.0091107836f * getLevel() * getLevel()) + 3.225598133f * getLevel()) + 4.2652911f;
 
    // Unknown if correct, but lineary adjust rage conversion above level 70
    if (getLevel() > 70)
        rageconversion += 13.27f * (getLevel() - 70);
 
    if (attacker)
    {
        addRage = (damage / rageconversion * 7.5f + weaponSpeedHitFactor) / 2;
 
        // talent who gave more rage on attack
        AddPct(addRage, GetTotalAuraModifier(SPELL_AURA_MOD_RAGE_FROM_DAMAGE_DEALT));
    }
    else
    {
        addRage = damage / rageconversion * 2.5f;
 
        // Berserker Rage effect
        if (HasAura(18499))
            addRage *= 3.0f;
    }
 
    addRage *= sWorld->getRate(RATE_POWER_RAGE_INCOME);
 
    ModifyPower(POWER_RAGE, uint32(addRage * 10));
}

◆ RollMeleeOutcomeAgainst() [1/2]

MeleeHitOutcome Unit::RollMeleeOutcomeAgainst	(	Unit const *	victim,
		WeaponAttackType	attType
	)		const

Definition at line 2731 of file Unit.cpp.

{
    // This is only wrapper
 
    // Miss chance based on melee
    //float miss_chance = MeleeMissChanceCalc(victim, attType);
    float miss_chance = MeleeSpellMissChance(victim, attType, int32(GetWeaponSkillValue(attType, victim)) - int32(victim->GetMaxSkillValueForLevel(this)), 0);
 
    // Critical hit chance
    float crit_chance = GetUnitCriticalChance(attType, victim);
    if( crit_chance < 0 )
        crit_chance = 0;
 
    float dodge_chance = victim->GetUnitDodgeChance();
    float block_chance = victim->GetUnitBlockChance();
    float parry_chance = victim->GetUnitParryChance();
 
    // Useful if want to specify crit & miss chances for melee, else it could be removed
    //LOG_DEBUG("entities.unit", "MELEE OUTCOME: miss {} crit {} dodge {} parry {} block {}", miss_chance, crit_chance, dodge_chance, parry_chance, block_chance);
 
    return RollMeleeOutcomeAgainst(victim, attType, int32(crit_chance * 100), int32(miss_chance * 100), int32(dodge_chance * 100), int32(parry_chance * 100), int32(block_chance * 100));
}

◆ RollMeleeOutcomeAgainst() [2/2]

MeleeHitOutcome Unit::RollMeleeOutcomeAgainst	(	Unit const *	victim,
		WeaponAttackType	attType,
		int32	crit_chance,
		int32	miss_chance,
		int32	dodge_chance,
		int32	parry_chance,
		int32	block_chance
	)		const

Definition at line 2754 of file Unit.cpp.

{
    if (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsEvadingAttacks())
    {
        return MELEE_HIT_EVADE;
    }
 
    int32 attackerMaxSkillValueForLevel = GetMaxSkillValueForLevel(victim);
    int32 victimMaxSkillValueForLevel = victim->GetMaxSkillValueForLevel(this);
 
    int32 attackerWeaponSkill = GetWeaponSkillValue(attType, victim);
    int32 victimDefenseSkill = victim->GetDefenseSkillValue(this);
 
    sScriptMgr->OnBeforeRollMeleeOutcomeAgainst(this, victim, attType, attackerMaxSkillValueForLevel, victimMaxSkillValueForLevel, attackerWeaponSkill, victimDefenseSkill, crit_chance, miss_chance, dodge_chance, parry_chance, block_chance);
 
    // bonus from skills is 0.04%
    int32    skillBonus  = 4 * (attackerWeaponSkill - victimMaxSkillValueForLevel);
    int32    sum = 0, tmp = 0;
    int32    roll = urand (0, 10000);
 
    LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: skill bonus of {} for attacker", skillBonus);
    //LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: rolled {}, miss {}, dodge {}, parry {}, block {}, crit {}",
    //    roll, miss_chance, dodge_chance, parry_chance, block_chance, crit_chance);
 
    tmp = miss_chance;
 
    if (tmp > 0 && roll < (sum += tmp))
    {
        LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: MISS");
        return MELEE_HIT_MISS;
    }
 
    // Dodge chance
 
    // only players can't dodge if attacker is behind
    if (victim->GetTypeId() == TYPEID_PLAYER && !victim->HasInArc(M_PI, this) && !victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
    {
        //LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: attack came from behind and victim was a player.");
    }
    // Xinef: do not allow to dodge with CREATURE_FLAG_EXTRA_NO_DODGE flag
    else if (victim->GetTypeId() == TYPEID_PLAYER || !(victim->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_DODGE))
    {
        // Reduce dodge chance by attacker expertise rating
        if (GetTypeId() == TYPEID_PLAYER)
            dodge_chance -= int32(ToPlayer()->GetExpertiseDodgeOrParryReduction(attType) * 100);
        else
            dodge_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
 
        // Modify dodge chance by attacker SPELL_AURA_MOD_COMBAT_RESULT_CHANCE
        dodge_chance += GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_COMBAT_RESULT_CHANCE, VICTIMSTATE_DODGE) * 100;
        dodge_chance = int32 (float (dodge_chance) * GetTotalAuraMultiplier(SPELL_AURA_MOD_ENEMY_DODGE));
 
        tmp = dodge_chance;
 
        // xinef: if casting or stunned - cant dodge
        if (victim->IsNonMeleeSpellCast(false, false, true) || victim->HasUnitState(UNIT_STATE_CONTROLLED))
            tmp = 0;
 
        if ((tmp > 0)                                        // check if unit _can_ dodge
                && ((tmp -= skillBonus) > 0)
                && roll < (sum += tmp))
        {
            LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: DODGE <{}, {})", sum - tmp, sum);
            return MELEE_HIT_DODGE;
        }
    }
 
    // parry & block chances
 
    // check if attack comes from behind, nobody can parry or block if attacker is behind
    if (!victim->HasInArc(M_PI, this) && !victim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
    {
        LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: attack came from behind.");
    }
    else
    {
        // Reduce parry chance by attacker expertise rating
        if (GetTypeId() == TYPEID_PLAYER)
            parry_chance -= int32(ToPlayer()->GetExpertiseDodgeOrParryReduction(attType) * 100);
        else
            parry_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
 
        if (victim->GetTypeId() == TYPEID_PLAYER || !(victim->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_PARRY))
        {
            tmp = parry_chance;
 
            // xinef: cant parry while casting or while stunned
            if (victim->IsNonMeleeSpellCast(false, false, true) || victim->HasUnitState(UNIT_STATE_CONTROLLED))
                tmp = 0;
 
            if (tmp > 0                                         // check if unit _can_ parry
                    && (tmp -= skillBonus) > 0
                    && roll < (sum += tmp))
            {
                LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: PARRY <{}, {})", sum - tmp, sum);
                return MELEE_HIT_PARRY;
            }
        }
 
        if (victim->GetTypeId() == TYPEID_PLAYER || !(victim->ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_BLOCK))
        {
            tmp = block_chance;
 
            // xinef: cant block while casting or while stunned
            if (victim->IsNonMeleeSpellCast(false, false, true) || victim->HasUnitState(UNIT_STATE_CONTROLLED))
                tmp = 0;
 
            if (tmp > 0                                          // check if unit _can_ block
                    && (tmp -= skillBonus) > 0
                    && roll < (sum += tmp))
            {
                LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: BLOCK <{}, {})", sum - tmp, sum);
                return MELEE_HIT_BLOCK;
            }
        }
    }
 
    // Max 40% chance to score a glancing blow against mobs that are higher level (can do only players and pets and not with ranged weapon)
    if (attType != RANGED_ATTACK &&
            (GetTypeId() == TYPEID_PLAYER || IsPet()) &&
            victim->GetTypeId() != TYPEID_PLAYER && !victim->IsPet() &&
            getLevel() < victim->getLevelForTarget(this))
    {
        // cap possible value (with bonuses > max skill)
        int32 skill = attackerWeaponSkill;
        int32 maxskill = attackerMaxSkillValueForLevel;
        skill = (skill > maxskill) ? maxskill : skill;
 
        tmp = (10 + (victimDefenseSkill - skill)) * 100;
        tmp = tmp > 4000 ? 4000 : tmp;
        if (roll < (sum += tmp))
        {
            LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: GLANCING <{}, {})", sum - 4000, sum);
            return MELEE_HIT_GLANCING;
        }
    }
 
    // mobs can score crushing blows if they're 4 or more levels above victim
    if (getLevelForTarget(victim) >= victim->getLevelForTarget(this) + 4 &&
            // can be from by creature (if can) or from controlled player that considered as creature
            !IsControlledByPlayer() &&
            !(GetTypeId() == TYPEID_UNIT && ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_CRUSHING_BLOWS))
    {
        // when their weapon skill is 15 or more above victim's defense skill
        tmp = victimDefenseSkill;
        int32 tmpmax = victimMaxSkillValueForLevel;
        // having defense above your maximum (from items, talents etc.) has no effect
        tmp = tmp > tmpmax ? tmpmax : tmp;
        // tmp = mob's level * 5 - player's current defense skill
        tmp = attackerMaxSkillValueForLevel - tmp;
        if (tmp >= 15)
        {
            // add 2% chance per lacking skill point, min. is 15%
            tmp = tmp * 200 - 1500;
            if (roll < (sum += tmp))
            {
                LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: CRUSHING <{}, {})", sum - tmp, sum);
                return MELEE_HIT_CRUSHING;
            }
        }
    }
 
    // Critical chance
    tmp = crit_chance;
 
    if (tmp > 0 && roll < (sum += tmp))
    {
        LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: CRIT <{}, {})", sum - tmp, sum);
        if (GetTypeId() == TYPEID_UNIT && (ToCreature()->GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_NO_CRIT))
        {
            LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: CRIT DISABLED)");
        }
        else
            return MELEE_HIT_CRIT;
    }
 
    LOG_DEBUG("entities.unit", "RollMeleeOutcomeAgainst: NORMAL");
    return MELEE_HIT_NORMAL;
}

◆ Say() [1/2]

void Unit::Say	(	std::string_view	text,
		Language	language,
		WorldObject const *	target = `nullptr`
	)

virtual

Reimplemented in Player.

Definition at line 21143 of file Unit.cpp.

{
    Talk(text, CHAT_MSG_MONSTER_SAY, language, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), target);
}

◆ Say() [2/2]

void Unit::Say	(	uint32	textId,
		WorldObject const *	target = `nullptr`
	)

virtual

Reimplemented in Player.

Definition at line 21185 of file Unit.cpp.

{
    Talk(textId, CHAT_MSG_MONSTER_SAY, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), target);
}

◆ SelectNearbyNoTotemTarget()

Unit * Unit::SelectNearbyNoTotemTarget	(	Unit *	exclude = `nullptr`,
		float	dist = `NOMINAL_MELEE_RANGE`
	)		const

Definition at line 17080 of file Unit.cpp.

{
    std::list<Unit*> targets;
    Acore::AnyUnfriendlyNoTotemUnitInObjectRangeCheck u_check(this, this, dist);
    Acore::UnitListSearcher<Acore::AnyUnfriendlyNoTotemUnitInObjectRangeCheck> searcher(this, targets, u_check);
    Cell::VisitAllObjects(this, searcher, dist);
 
    // remove current target
    if (GetVictim())
        targets.remove(GetVictim());
 
    if (exclude)
        targets.remove(exclude);
 
    // remove not LoS targets
    for (std::list<Unit*>::iterator tIter = targets.begin(); tIter != targets.end();)
    {
        if (!IsWithinLOSInMap(*tIter) || !IsValidAttackTarget(*tIter))
        {
            std::list<Unit*>::iterator tIter2 = tIter;
            ++tIter;
            targets.erase(tIter2);
        }
        else
            ++tIter;
    }
 
    // no appropriate targets
    if (targets.empty())
        return nullptr;
 
    // select random
    return Acore::Containers::SelectRandomContainerElement(targets);
}

◆ SelectNearbyTarget()

Unit * Unit::SelectNearbyTarget	(	Unit *	exclude = `nullptr`,
		float	dist = `NOMINAL_MELEE_RANGE`
	)		const

Definition at line 17045 of file Unit.cpp.

{
    std::list<Unit*> targets;
    Acore::AnyUnfriendlyUnitInObjectRangeCheck u_check(this, this, dist);
    Acore::UnitListSearcher<Acore::AnyUnfriendlyUnitInObjectRangeCheck> searcher(this, targets, u_check);
    Cell::VisitAllObjects(this, searcher, dist);
 
    // remove current target
    if (GetVictim())
        targets.remove(GetVictim());
 
    if (exclude)
        targets.remove(exclude);
 
    // remove not LoS targets
    for (std::list<Unit*>::iterator tIter = targets.begin(); tIter != targets.end();)
    {
        if (!IsWithinLOSInMap(*tIter) || !IsValidAttackTarget(*tIter))
        {
            std::list<Unit*>::iterator tIter2 = tIter;
            ++tIter;
            targets.erase(tIter2);
        }
        else
            ++tIter;
    }
 
    // no appropriate targets
    if (targets.empty())
        return nullptr;
 
    // select random
    return Acore::Containers::SelectRandomContainerElement(targets);
}

◆ SendAttackStateUpdate() [1/2]

void Unit::SendAttackStateUpdate ( CalcDamageInfo * damageInfo )

Probably used for debugging purposes, as it is not known to appear on retail servers

Definition at line 6379 of file Unit.cpp.

{
    LOG_DEBUG("entities.unit", "WORLD: Sending SMSG_ATTACKERSTATEUPDATE");
 
    uint32 tmpDamage[MAX_ITEM_PROTO_DAMAGES] = { };
    uint32 tmpAbsorb[MAX_ITEM_PROTO_DAMAGES] = { };
    for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
    {
        //IF we are in cheat mode we swap absorb with damage and set damage to 0, this way we can still debug damage but our hp bar will not drop
        tmpDamage[i] = damageInfo->damages[i].damage;
        tmpAbsorb[i] = damageInfo->damages[i].absorb;
        if (damageInfo->target->GetTypeId() == TYPEID_PLAYER && damageInfo->target->ToPlayer()->GetCommandStatus(CHEAT_GOD))
        {
            tmpAbsorb[i] = tmpDamage[i];
            tmpDamage[i] = 0;
        }
    }
 
    uint32 count = 1;
    if (tmpDamage[1] || tmpAbsorb[1] || damageInfo->damages[1].resist)
    {
        ++count;
    }
 
    size_t const maxsize = 4 + 5 + 5 + 4 + 4 + 1 + count * (4 + 4 + 4 + 4 + 4) + 1 + 4 + 4 + 4 + 4 + 4 * 12;
    WorldPacket data(SMSG_ATTACKERSTATEUPDATE, maxsize);            // we guess size
    data << uint32(damageInfo->HitInfo);
    data << damageInfo->attacker->GetPackGUID();
    data << damageInfo->target->GetPackGUID();
    data << uint32(tmpDamage[0] + tmpDamage[1]);                    // Full damage
    int32 overkill = tmpDamage[0] + tmpDamage[1] - damageInfo->target->GetHealth();
    data << uint32(overkill < 0 ? 0 : overkill);                    // Overkill
    data << uint8(count);                                           // Sub damage count
 
    for (uint32 i = 0; i < count; ++i)
    {
        data << uint32(damageInfo->damages[i].damageSchoolMask);    // School of sub damage
        data << float(tmpDamage[i]);                                // sub damage
        data << uint32(tmpDamage[i]);                               // Sub Damage
    }
 
    if (damageInfo->HitInfo & (HITINFO_FULL_ABSORB | HITINFO_PARTIAL_ABSORB))
    {
        for (uint32 i = 0; i < count; ++i)
        {
            data << uint32(tmpAbsorb[i]);                           // Absorb
        }
    }
 
    if (damageInfo->HitInfo & (HITINFO_FULL_RESIST | HITINFO_PARTIAL_RESIST))
    {
        for (uint32 i = 0; i < count; ++i)
        {
            data << uint32(damageInfo->damages[i].resist);          // Resist
        }
    }
 
    data << uint8(damageInfo->TargetState);
    data << uint32(0);  // Unknown attackerstate
    data << uint32(0);  // Melee spellid
 
    if (damageInfo->HitInfo & HITINFO_BLOCK)
        data << uint32(damageInfo->blocked_amount);
 
    if (damageInfo->HitInfo & HITINFO_RAGE_GAIN)
        data << uint32(0);
 
    if (damageInfo->HitInfo & HITINFO_UNK1)
    {
        data << uint32(0);
        data << float(0);
        data << float(0);
        data << float(0);
        data << float(0);
        data << float(0);
        data << float(0);
        data << float(0);
        data << float(0);
        data << float(0);       // Found in a loop with 1 iteration
        data << float(0);       // ditto ^
        data << uint32(0);
    }
 
    SendMessageToSet(&data, true);
}

◆ SendAttackStateUpdate() [2/2]

void Unit::SendAttackStateUpdate	(	uint32	HitInfo,
		Unit *	target,
		uint8	SwingType,
		SpellSchoolMask	damageSchoolMask,
		uint32	Damage,
		uint32	AbsorbDamage,
		uint32	Resist,
		VictimState	TargetState,
		uint32	BlockedAmount
	)

Definition at line 6466 of file Unit.cpp.

{
    CalcDamageInfo dmgInfo;
    dmgInfo.HitInfo = HitInfo;
    dmgInfo.attacker = this;
    dmgInfo.target = target;
 
    dmgInfo.damages[0].damage = Damage - AbsorbDamage - Resist - BlockedAmount;
    dmgInfo.damages[0].damageSchoolMask = damageSchoolMask;
    dmgInfo.damages[0].absorb = AbsorbDamage;
    dmgInfo.damages[0].resist = Resist;
 
    dmgInfo.damages[1].damage = 0;
    dmgInfo.damages[1].damageSchoolMask = 0;
    dmgInfo.damages[1].absorb = 0;
    dmgInfo.damages[1].resist = 0;
 
    dmgInfo.TargetState = TargetState;
    dmgInfo.blocked_amount = BlockedAmount;
    SendAttackStateUpdate(&dmgInfo);
}

◆ SendChangeCurrentVictimOpcode()

void Unit::SendChangeCurrentVictimOpcode ( HostileReference * pHostileReference )

Definition at line 20104 of file Unit.cpp.

{
    if (!GetThreatMgr().isThreatListEmpty())
    {
        uint32 count = GetThreatMgr().GetThreatList().size();
 
        LOG_DEBUG("entities.unit", "WORLD: Send SMSG_HIGHEST_THREAT_UPDATE Message");
        WorldPacket data(SMSG_HIGHEST_THREAT_UPDATE, 8 + 8 + count * 8);
        data << GetPackGUID();
        data << pHostileReference->getUnitGuid().WriteAsPacked();
        data << uint32(count);
        ThreatContainer::StorageType const& tlist = GetThreatMgr().GetThreatList();
        for (ThreatContainer::StorageType::const_iterator itr = tlist.begin(); itr != tlist.end(); ++itr)
        {
            data << (*itr)->getUnitGuid().WriteAsPacked();
            data << uint32((*itr)->GetThreat() * 100);
        }
        SendMessageToSet(&data, false);
    }
}

◆ SendClearTarget()

void Unit::SendClearTarget ( )

Definition at line 20316 of file Unit.cpp.

{
    WorldPacket data(SMSG_BREAK_TARGET, GetPackGUID().size());
    data << GetPackGUID();
    SendMessageToSet(&data, false);
}

◆ SendClearThreatListOpcode()

void Unit::SendClearThreatListOpcode ( )

Definition at line 20125 of file Unit.cpp.

{
    LOG_DEBUG("entities.unit", "WORLD: Send SMSG_THREAT_CLEAR Message");
    WorldPacket data(SMSG_THREAT_CLEAR, 8);
    data << GetPackGUID();
    SendMessageToSet(&data, false);
}

◆ SendComboPoints()

void Unit::SendComboPoints ( )

Definition at line 16942 of file Unit.cpp.

{
    if (m_cleanupDone)
    {
        return;
    }
 
    PackedGuid const packGUID = m_comboTarget ? m_comboTarget->GetPackGUID() : PackedGuid();
    if (Player* playerMe = ToPlayer())
    {
        WorldPacket data(SMSG_UPDATE_COMBO_POINTS, packGUID.size() + 1);
        data << packGUID;
        data << uint8(m_comboPoints);
        playerMe->SendDirectMessage(&data);
    }
 
    ObjectGuid ownerGuid = GetCharmerOrOwnerGUID();
    Player* owner = nullptr;
    if (ownerGuid.IsPlayer())
    {
        owner = ObjectAccessor::GetPlayer(*this, ownerGuid);
    }
 
    if (m_movedByPlayer || owner)
    {
        WorldPacket data(SMSG_PET_UPDATE_COMBO_POINTS, GetPackGUID().size() + packGUID.size() + 1);
        data << GetPackGUID();
        data << packGUID;
        data << uint8(m_comboPoints);
 
        if (m_movedByPlayer)
            m_movedByPlayer->ToPlayer()->SendDirectMessage(&data);
 
        if (owner && owner != m_movedByPlayer)
            owner->SendDirectMessage(&data);
    }
}

◆ SendEnergizeSpellLog()

void Unit::SendEnergizeSpellLog	(	Unit *	victim,
		uint32	SpellID,
		uint32	Damage,
		Powers	powertype
	)

Definition at line 11204 of file Unit.cpp.

{
    WorldPacket data(SMSG_SPELLENERGIZELOG, (8 + 8 + 4 + 4 + 4 + 1));
    data << victim->GetPackGUID();
    data << GetPackGUID();
    data << uint32(spellID);
    data << uint32(powerType);
    data << uint32(damage);
    SendMessageToSet(&data, true);
}

◆ SendHealSpellLog()

void Unit::SendHealSpellLog	(	Unit *	victim,
		uint32	SpellID,
		uint32	Damage,
		uint32	OverHeal,
		uint32	Absorb,
		bool	critical = `false`
	)

Definition at line 11175 of file Unit.cpp.

{
    // we guess size
    WorldPacket data(SMSG_SPELLHEALLOG, (8 + 8 + 4 + 4 + 4 + 4 + 1 + 1));
    data << victim->GetPackGUID();
    data << GetPackGUID();
    data << uint32(SpellID);
    data << uint32(Damage);
    data << uint32(OverHeal);
    data << uint32(Absorb); // Absorb amount
    data << uint8(critical ? 1 : 0);
    data << uint8(0); // unused
    SendMessageToSet(&data, true);
}

◆ SendMeleeAttackStart()

void Unit::SendMeleeAttackStart	(	Unit *	victim,
		Player *	sendTo = `nullptr`
	)

Definition at line 3011 of file Unit.cpp.

{
    WorldPacket data(SMSG_ATTACKSTART, 8 + 8);
    data << GetGUID();
    data << victim->GetGUID();
    if (sendTo)
        sendTo->SendDirectMessage(&data);
    else
        SendMessageToSet(&data, true);
    LOG_DEBUG("entities.unit", "WORLD: Sent SMSG_ATTACKSTART");
}

◆ SendMeleeAttackStop()

void Unit::SendMeleeAttackStop ( Unit * victim = nullptr )

Can also take the value 0x01, which seems related to updating rotation

Definition at line 3023 of file Unit.cpp.

{
    // pussywizard: calling SendMeleeAttackStop without clearing UNIT_STATE_MELEE_ATTACKING and then AttackStart the same player may spoil npc rotating!
    // pussywizard: this happens in some boss scripts, just add clearing here
    // ClearUnitState(UNIT_STATE_MELEE_ATTACKING); // commented out for now
 
    WorldPacket data(SMSG_ATTACKSTOP, (8 + 8 + 4));
    data << GetPackGUID();
    data << (victim ? victim->GetPackGUID() : PackedGuid());
    data << uint32(0);                                     
    SendMessageToSet(&data, true);
    LOG_DEBUG("entities.unit", "WORLD: Sent SMSG_ATTACKSTOP");
 
    if (victim)
        LOG_DEBUG("entities.unit", "{} {} stopped attacking {} {}", (GetTypeId() == TYPEID_PLAYER ? "Player" : "Creature"), GetGUID().ToString(), (victim->GetTypeId() == TYPEID_PLAYER ? "player" : "creature"), victim->GetGUID().ToString());
    else
        LOG_DEBUG("entities.unit", "{} {} stopped attacking", (GetTypeId() == TYPEID_PLAYER ? "Player" : "Creature"), GetGUID().ToString());
}

◆ SendMonsterMove()

void Unit::SendMonsterMove	(	float	NewPosX,
		float	NewPosY,
		float	NewPosZ,
		uint32	TransitTime,
		SplineFlags	sf = `SPLINEFLAG_WALK_MODE`
	)

Definition at line 555 of file Unit.cpp.

{
    WorldPacket data(SMSG_MONSTER_MOVE, 1 + 12 + 4 + 1 + 4 + 4 + 4 + 12 + GetPackGUID().size());
    data << GetPackGUID();
 
    data << uint8(0);                                       // new in 3.1
    data << GetPositionX() << GetPositionY() << GetPositionZ();
    data << GameTime::GetGameTimeMS().count();
    data << uint8(0);
    data << uint32(sf);
    data << TransitTime;                                           // Time in between points
    data << uint32(1);                                      // 1 single waypoint
    data << NewPosX << NewPosY << NewPosZ;                  // the single waypoint Point B
 
    SendMessageToSet(&data, true);
}

◆ SendMovementFeatherFall()

void Unit::SendMovementFeatherFall ( Player * sendTo )

Definition at line 20746 of file Unit.cpp.

{
    if (!movespline->Initialized())
        return;
    WorldPacket data(SMSG_SPLINE_MOVE_FEATHER_FALL, 9);
    data << GetPackGUID();
    sendTo->SendDirectMessage(&data);
}

◆ SendMovementFlagUpdate()

void Unit::SendMovementFlagUpdate ( bool self = false )

Definition at line 16790 of file Unit.cpp.

{
    WorldPacket data;
    BuildHeartBeatMsg(&data);
    SendMessageToSet(&data, self);
}

◆ SendMovementHover()

void Unit::SendMovementHover ( Player * sendTo )

Definition at line 20783 of file Unit.cpp.

{
    if (!movespline->Initialized())
        return;
    WorldPacket data(SMSG_SPLINE_MOVE_SET_HOVER, 9);
    data << GetPackGUID();
    sendTo->SendDirectMessage(&data);
}

◆ SendMovementWaterWalking()

void Unit::SendMovementWaterWalking ( Player * sendTo )

Definition at line 20724 of file Unit.cpp.

{
    if (!movespline->Initialized())
        return;
    WorldPacket data(SMSG_SPLINE_MOVE_WATER_WALK, 9);
    data << GetPackGUID();
    sendTo->SendDirectMessage(&data);
}

◆ SendPeriodicAuraLog()

void Unit::SendPeriodicAuraLog ( SpellPeriodicAuraLogInfo * pInfo )

Definition at line 6289 of file Unit.cpp.

{
    AuraEffect const* aura = pInfo->auraEff;
    WorldPacket data(SMSG_PERIODICAURALOG, 30);
    data << GetPackGUID();
    data << aura->GetCasterGUID().WriteAsPacked();
    data << uint32(aura->GetId());                          // spellId
    data << uint32(1);                                      // count
    data << uint32(aura->GetAuraType());                    // auraId
    switch (aura->GetAuraType())
    {
        case SPELL_AURA_PERIODIC_DAMAGE:
        case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
            {
                //IF we are in cheat mode we swap absorb with damage and set damage to 0, this way we can still debug damage but our hp bar will not drop
                uint32 damage = pInfo->damage;
                uint32 absorb = pInfo->absorb;
                if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetCommandStatus(CHEAT_GOD))
                {
                    absorb = damage;
                    damage = 0;
                }
 
                data << uint32(damage);                         // damage
                data << uint32(pInfo->overDamage);              // overkill?
                data << uint32(aura->GetSpellInfo()->GetSchoolMask());
                data << uint32(absorb);                         // absorb
                data << uint32(pInfo->resist);                  // resist
                data << uint8(pInfo->critical);                 // new 3.1.2 critical tick
            }
            break;
        case SPELL_AURA_PERIODIC_HEAL:
        case SPELL_AURA_OBS_MOD_HEALTH:
            data << uint32(pInfo->damage);                  // damage
            data << uint32(pInfo->overDamage);              // overheal
            data << uint32(pInfo->absorb);                  // absorb
            data << uint8(pInfo->critical);                 // new 3.1.2 critical tick
            break;
        case SPELL_AURA_OBS_MOD_POWER:
        case SPELL_AURA_PERIODIC_ENERGIZE:
            data << uint32(aura->GetMiscValue());           // power type
            data << uint32(pInfo->damage);                  // damage
            break;
        case SPELL_AURA_PERIODIC_MANA_LEECH:
            data << uint32(aura->GetMiscValue());           // power type
            data << uint32(pInfo->damage);                  // amount
            data << float(pInfo->multiplier);               // gain multiplier
            break;
        default:
            LOG_ERROR("entities.unit", "Unit::SendPeriodicAuraLog: unknown aura {}", uint32(aura->GetAuraType()));
            return;
    }
 
    SendMessageToSet(&data, true);
}

◆ SendPetActionFeedback()

void Unit::SendPetActionFeedback ( uint8 msg )

-------—Pet responses methods--------------—

Definition at line 16694 of file Unit.cpp.

{
    Unit* owner = GetOwner();
    if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
        return;
 
    WorldPacket data(SMSG_PET_ACTION_FEEDBACK, 1);
    data << uint8(msg);
    owner->ToPlayer()->GetSession()->SendPacket(&data);
}

◆ SendPetAIReaction()

void Unit::SendPetAIReaction ( ObjectGuid guid )

Definition at line 16717 of file Unit.cpp.

{
    Unit* owner = GetOwner();
    if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
        return;
 
    WorldPacket data(SMSG_AI_REACTION, 8 + 4);
    data << guid;
    data << uint32(AI_REACTION_HOSTILE);
    owner->ToPlayer()->GetSession()->SendPacket(&data);
}

◆ SendPetTalk()

void Unit::SendPetTalk ( uint32 pettalk )

Definition at line 16705 of file Unit.cpp.

{
    Unit* owner = GetOwner();
    if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
        return;
 
    WorldPacket data(SMSG_PET_ACTION_SOUND, 8 + 4);
    data << GetGUID();
    data << uint32(pettalk);
    owner->ToPlayer()->GetSession()->SendPacket(&data);
}

◆ SendPlaySpellImpact()

void Unit::SendPlaySpellImpact	(	ObjectGuid	guid,
		uint32	id
	)

Definition at line 18951 of file Unit.cpp.

{
    WorldPacket data(SMSG_PLAY_SPELL_IMPACT, 8 + 4);
    data << guid;       // target
    data << uint32(id); // SpellVisualKit.dbc index
    SendMessageToSet(&data, true);
}

◆ SendPlaySpellVisual()

void Unit::SendPlaySpellVisual ( uint32 id )

Definition at line 18943 of file Unit.cpp.

{
    WorldPacket data(SMSG_PLAY_SPELL_VISUAL, 8 + 4);
    data << GetGUID();
    data << uint32(id); // SpellVisualKit.dbc index
    SendMessageToSet(&data, true);
}

◆ SendRemoveFromThreatListOpcode()

void Unit::SendRemoveFromThreatListOpcode ( HostileReference * pHostileReference )

Definition at line 20133 of file Unit.cpp.

{
    LOG_DEBUG("entities.unit", "WORLD: Send SMSG_THREAT_REMOVE Message");
    WorldPacket data(SMSG_THREAT_REMOVE, 8 + 8);
    data << GetPackGUID();
    data << pHostileReference->getUnitGuid().WriteAsPacked();
    SendMessageToSet(&data, false);
}

◆ SendSpellDamageImmune()

void Unit::SendSpellDamageImmune	(	Unit *	target,
		uint32	spellId
	)

Definition at line 6369 of file Unit.cpp.

{
    WorldPacket data(SMSG_SPELLORDAMAGE_IMMUNE, 8 + 8 + 4 + 1);
    data << GetGUID();
    data << target->GetGUID();
    data << uint32(spellId);
    data << uint8(0); // bool - log format: 0-default, 1-debug
    SendMessageToSet(&data, true);
}

◆ SendSpellDamageResist()

void Unit::SendSpellDamageResist	(	Unit *	target,
		uint32	spellId
	)

Definition at line 6359 of file Unit.cpp.

{
    WorldPacket data(SMSG_PROCRESIST, 8 + 8 + 4 + 1);
    data << GetGUID();
    data << target->GetGUID();
    data << uint32(spellId);
    data << uint8(0); // bool - log format: 0-default, 1-debug
    SendMessageToSet(&data, true);
}

◆ SendSpellMiss()

void Unit::SendSpellMiss	(	Unit *	target,
		uint32	spellID,
		SpellMissInfo	missInfo
	)

Definition at line 6345 of file Unit.cpp.

{
    WorldPacket data(SMSG_SPELLLOGMISS, (4 + 8 + 1 + 4 + 8 + 1));
    data << uint32(spellID);
    data << GetGUID();
    data << uint8(0);                                       // can be 0 or 1
    data << uint32(1);                                      // target count
    // for (i = 0; i < target count; ++i)
    data << target->GetGUID();                              // target GUID
    data << uint8(missInfo);
    // end loop
    SendMessageToSet(&data, true);
}

◆ SendSpellNonMeleeDamageLog() [1/2]

void Unit::SendSpellNonMeleeDamageLog ( SpellNonMeleeDamage * log )

Definition at line 6210 of file Unit.cpp.

{
    WorldPacket data(SMSG_SPELLNONMELEEDAMAGELOG, (16 + 4 + 4 + 4 + 1 + 4 + 4 + 1 + 1 + 4 + 4 + 1)); // we guess size
    //IF we are in cheat mode we swap absorb with damage and set damage to 0, this way we can still debug damage but our hp bar will not drop
    uint32 damage = log->damage;
    uint32 absorb = log->absorb;
    if (log->target->GetTypeId() == TYPEID_PLAYER && log->target->ToPlayer()->GetCommandStatus(CHEAT_GOD))
    {
        absorb = damage;
        damage = 0;
    }
    data << log->target->GetPackGUID();
    data << log->attacker->GetPackGUID();
    data << uint32(log->spellInfo->Id);
    data << uint32(damage);                                 // damage amount
    int32 overkill = damage - log->target->GetHealth();
    data << uint32(overkill > 0 ? overkill : 0);            // overkill
    data << uint8 (log->schoolMask);                        // damage school
    data << uint32(absorb);                                 // AbsorbedDamage
    data << uint32(log->resist);                            // resist
    data << uint8 (log->physicalLog);                       // if 1, then client show spell name (example: %s's ranged shot hit %s for %u school or %s suffers %u school damage from %s's spell_name
    data << uint8 (log->unused);                            // unused
    data << uint32(log->blocked);                           // blocked
    data << uint32(log->HitInfo);
    data << uint32(log->HitInfo);
    data << uint8(log->HitInfo & (SPELL_HIT_TYPE_CRIT_DEBUG | SPELL_HIT_TYPE_HIT_DEBUG | SPELL_HIT_TYPE_ATTACK_TABLE_DEBUG));
    //if (log->HitInfo & SPELL_HIT_TYPE_CRIT_DEBUG)
    //{
    //    data << float(log->CritRoll);
    //    data << float(log->CritNeeded);
    //}
    //if (log->HitInfo & SPELL_HIT_TYPE_HIT_DEBUG)
    //{
    //    data << float(log->HitRoll);
    //    data << float(log->HitNeeded);
    //}
    //if (log->HitInfo & SPELL_HIT_TYPE_ATTACK_TABLE_DEBUG)
    //{
    //    data << float(log->MissChance);
    //    data << float(log->DodgeChance);
    //    data << float(log->ParryChance);
    //    data << float(log->BlockChance);
    //    data << float(log->GlanceChance);
    //    data << float(log->CrushChance);
    //}
    SendMessageToSet(&data, true);
}

◆ SendSpellNonMeleeDamageLog() [2/2]

void Unit::SendSpellNonMeleeDamageLog	(	Unit *	target,
		SpellInfo const *	spellInfo,
		uint32	Damage,
		SpellSchoolMask	damageSchoolMask,
		uint32	AbsorbedDamage,
		uint32	Resist,
		bool	PhysicalDamage,
		uint32	Blocked,
		bool	CriticalHit = `false`,
		bool	Split = `false`
	)

Definition at line 6258 of file Unit.cpp.

{
    SpellNonMeleeDamage log(this, target, spellInfo, damageSchoolMask);
    log.damage = Damage;
    log.absorb = AbsorbedDamage;
    log.resist = Resist;
    log.physicalLog = PhysicalDamage;
    log.blocked = Blocked;
    log.HitInfo = 0;
    if (CriticalHit)
    {
        log.HitInfo |= SPELL_HIT_TYPE_CRIT;
    }
    if (Split)
    {
        log.HitInfo |= SPELL_HIT_TYPE_SPLIT;
    }
    SendSpellNonMeleeDamageLog(&log);
}

◆ SendSpellNonMeleeReflectLog()

void Unit::SendSpellNonMeleeReflectLog	(	SpellNonMeleeDamage *	log,
		Unit *	attacker
	)

Definition at line 6178 of file Unit.cpp.

{
    // Xinef: function for players only, placed in unit because of cosmetics
    if (GetTypeId() != TYPEID_PLAYER)
        return;
 
    WorldPacket data(SMSG_SPELLNONMELEEDAMAGELOG, (16 + 4 + 4 + 4 + 1 + 4 + 4 + 1 + 1 + 4 + 4 + 1)); // we guess size
    //IF we are in cheat mode we swap absorb with damage and set damage to 0, this way we can still debug damage but our hp bar will not drop
    uint32 damage = log->damage;
    uint32 absorb = log->absorb;
    if (log->target->GetTypeId() == TYPEID_PLAYER && log->target->ToPlayer()->GetCommandStatus(CHEAT_GOD))
    {
        absorb = damage;
        damage = 0;
    }
    data << log->target->GetPackGUID();
    data << attacker->GetPackGUID();
    data << uint32(log->spellInfo->Id);
    data << uint32(damage);                                 // damage amount
    int32 overkill = damage - log->target->GetHealth();
    data << uint32(overkill > 0 ? overkill : 0);            // overkill
    data << uint8 (log->schoolMask);                        // damage school
    data << uint32(absorb);                                 // AbsorbedDamage
    data << uint32(log->resist);                            // resist
    data << uint8 (log->physicalLog);                       // if 1, then client show spell name (example: %s's ranged shot hit %s for %u school or %s suffers %u school damage from %s's spell_name
    data << uint8 (log->unused);                            // unused
    data << uint32(log->blocked);                           // blocked
    data << uint32(log->HitInfo);
    data << uint8 (0);                                      // flag to use extend data
    ToPlayer()->SendDirectMessage(&data);
}

◆ SendTameFailure()

void Unit::SendTameFailure ( uint8 result )

Definition at line 20008 of file Unit.cpp.

{
    WorldPacket data(SMSG_PET_TAME_FAILURE, 1);
    data << uint8(result);
    ToPlayer()->SendDirectMessage(&data);
}

◆ SendTeleportPacket()

void Unit::SendTeleportPacket ( Position & pos )

Definition at line 20015 of file Unit.cpp.

{
    Position oldPos = { GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation() };
    if (GetTypeId() == TYPEID_UNIT)
        Relocate(&pos);
 
    WorldPacket data2(MSG_MOVE_TELEPORT, 38);
    data2 << GetPackGUID();
    BuildMovementPacket(&data2);
    if (GetTypeId() == TYPEID_UNIT)
        Relocate(&oldPos);
    if (GetTypeId() == TYPEID_PLAYER)
        Relocate(&pos);
    SendMessageToSet(&data2, false);
}

◆ SendThreatListUpdate()

void Unit::SendThreatListUpdate ( )

Definition at line 20084 of file Unit.cpp.

{
    if (!GetThreatMgr().isThreatListEmpty())
    {
        uint32 count = GetThreatMgr().GetThreatList().size();
 
        //LOG_DEBUG("entities.unit", "WORLD: Send SMSG_THREAT_UPDATE Message");
        WorldPacket data(SMSG_THREAT_UPDATE, 8 + count * 8);
        data << GetPackGUID();
        data << uint32(count);
        ThreatContainer::StorageType const& tlist = GetThreatMgr().GetThreatList();
        for (ThreatContainer::StorageType::const_iterator itr = tlist.begin(); itr != tlist.end(); ++itr)
        {
            data << (*itr)->getUnitGuid().WriteAsPacked();
            data << uint32((*itr)->GetThreat() * 100);
        }
        SendMessageToSet(&data, false);
    }
}

◆ SetAI()

void Unit::SetAI ( UnitAI * newAI )

inline

Definition at line 1317 of file Unit.h.

1317{ i_AI = newAI; }

◆ SetArmor()

void Unit::SetArmor ( int32 val )

inline

Definition at line 1431 of file Unit.h.

1431{ SetResistance(SPELL_SCHOOL_NORMAL, val); }

Unit::SetResistance

void SetResistance(SpellSchools school, int32 val)

Definition: Unit.h:1435

◆ SetAttackTime()

void Unit::SetAttackTime	(	WeaponAttackType	att,
		uint32	val
	)

inline

Definition at line 1473 of file Unit.h.

1473{ SetFloatValue(static_cast<uint16>(UNIT_FIELD_BASEATTACKTIME) + att, val * m_modAttackSpeedPct[att]); }

Object::SetFloatValue

void SetFloatValue(uint16 index, float value)

Definition: Object.cpp:737

◆ setAttackTimer()

void Unit::setAttackTimer	(	WeaponAttackType	type,
		int32	time
	)

inline

Definition at line 1340 of file Unit.h.

1340{ m_attackTimer[type] = time; }

◆ SetAuraStack()

void Unit::SetAuraStack	(	uint32	spellId,
		Unit *	target,
		uint32	stack
	)

Definition at line 18934 of file Unit.cpp.

{
    Aura* aura = target->GetAura(spellId, GetGUID());
    if (!aura)
        aura = AddAura(spellId, target);
    if (aura && stack)
        aura->SetStackAmount(stack);
}

◆ SetBaseWeaponDamage()

void Unit::SetBaseWeaponDamage	(	WeaponAttackType	attType,
		WeaponDamageRange	damageRange,
		float	value,
		uint8	damageIndex = `0`
	)

inline

Definition at line 2115 of file Unit.h.

2115{ m_weaponDamage[attType][damageRange][damageIndex] = value; }

◆ SetCanDualWield()

virtual void Unit::SetCanDualWield ( bool value )

inlinevirtual

Reimplemented in Creature.

Definition at line 1346 of file Unit.h.

1346{ m_canDualWield = value; }

◆ SetCanFly()

bool Unit::SetCanFly	(	bool	enable,
		bool	packetOnly = `false`
	)

virtual

Reimplemented in Player, and Creature.

Definition at line 20693 of file Unit.cpp.

{
    if (enable == HasUnitMovementFlag(MOVEMENTFLAG_CAN_FLY))
        return false;
 
    if (enable)
    {
        AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
        RemoveUnitMovementFlag(MOVEMENTFLAG_FALLING);
    }
    else
    {
        RemoveUnitMovementFlag(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_MASK_MOVING_FLY);
    }
 
    return true;
}

◆ SetCanModifyStats()

void Unit::SetCanModifyStats ( bool modifyStats )

inline

Definition at line 2103 of file Unit.h.

2103{ m_canModifyStats = modifyStats; }

◆ SetCantProc()

void Unit::SetCantProc ( bool apply )

inline

Definition at line 2316 of file Unit.h.

    {
        if (apply)
            ++m_procDeep;
        else
        {
            ASSERT(m_procDeep);
            --m_procDeep;
        }
    }

◆ SetCharm()

void Unit::SetCharm	(	Unit *	target,
		bool	apply
	)

Definition at line 10824 of file Unit.cpp.

{
    if (apply)
    {
        if (GetTypeId() == TYPEID_PLAYER)
        {
            if (!AddGuidValue(UNIT_FIELD_CHARM, charm->GetGUID()))
                LOG_FATAL("entities.unit", "Player {} is trying to charm unit {}, but it already has a charmed unit {}", GetName(), charm->GetEntry(), GetCharmGUID().ToString());
 
            charm->m_ControlledByPlayer = true;
            // TODO: maybe we can use this flag to check if controlled by player
            charm->SetUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED);
        }
        else
            charm->m_ControlledByPlayer = false;
 
        // PvP, FFAPvP
        charm->SetByteValue(UNIT_FIELD_BYTES_2, 1, GetByteValue(UNIT_FIELD_BYTES_2, 1));
 
        if (!charm->AddGuidValue(UNIT_FIELD_CHARMEDBY, GetGUID()))
            LOG_FATAL("entities.unit", "Unit {} is being charmed, but it already has a charmer {}", charm->GetEntry(), charm->GetCharmerGUID().ToString());
 
        _isWalkingBeforeCharm = charm->IsWalking();
        if (_isWalkingBeforeCharm)
        {
            charm->SetWalk(false);
            charm->SendMovementFlagUpdate();
        }
 
        m_Controlled.insert(charm);
    }
    else
    {
        if (GetTypeId() == TYPEID_PLAYER)
        {
            if (!RemoveGuidValue(UNIT_FIELD_CHARM, charm->GetGUID()))
                LOG_FATAL("entities.unit", "Player {} is trying to uncharm unit {}, but it has another charmed unit {}", GetName(), charm->GetEntry(), GetCharmGUID().ToString());
        }
 
        if (!charm->RemoveGuidValue(UNIT_FIELD_CHARMEDBY, GetGUID()))
            LOG_FATAL("entities.unit", "Unit {} is being uncharmed, but it has another charmer {}", charm->GetEntry(), charm->GetCharmerGUID().ToString());
 
        if (charm->GetTypeId() == TYPEID_PLAYER)
        {
            charm->m_ControlledByPlayer = true;
            charm->SetUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED);
            charm->ToPlayer()->UpdatePvPState();
        }
        else if (Player* player = charm->GetCharmerOrOwnerPlayerOrPlayerItself())
        {
            charm->m_ControlledByPlayer = true;
            charm->SetUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED);
            charm->SetByteValue(UNIT_FIELD_BYTES_2, 1, player->GetByteValue(UNIT_FIELD_BYTES_2, 1));
 
            // Xinef: skip controlled erase if charmed unit is owned by charmer
            if (charm->IsInWorld() && !charm->IsDuringRemoveFromWorld() && player->GetGUID() == this->GetGUID() && (charm->IsPet() || charm->HasUnitTypeMask(UNIT_MASK_MINION)))
                return;
        }
        else
        {
            charm->m_ControlledByPlayer = false;
            charm->RemoveUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED);
            charm->SetByteValue(UNIT_FIELD_BYTES_2, 1, 0);
        }
 
        if (charm->IsWalking() != _isWalkingBeforeCharm)
        {
            charm->SetWalk(_isWalkingBeforeCharm);
            charm->SendMovementFlagUpdate(true); // send packet to self, to update movement state on player.
        }
 
        m_Controlled.erase(charm);
    }
}

◆ SetCharmedBy()

bool Unit::SetCharmedBy	(	Unit *	charmer,
		CharmType	type,
		AuraApplication const *	aurApp = `nullptr`
	)

Definition at line 18385 of file Unit.cpp.

{
    if (!charmer)
        return false;
 
    if (!charmer->IsInWorld() || charmer->IsDuringRemoveFromWorld())
    {
        return false;
    }
 
    // dismount players when charmed
    if (GetTypeId() == TYPEID_PLAYER)
        RemoveAurasByType(SPELL_AURA_MOUNTED);
 
    if (charmer->GetTypeId() == TYPEID_PLAYER)
        charmer->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
    ASSERT(type != CHARM_TYPE_POSSESS || charmer->GetTypeId() == TYPEID_PLAYER);
    if (type == CHARM_TYPE_VEHICLE && !IsVehicle()) // pussywizard
        throw 1;
    ASSERT((type == CHARM_TYPE_VEHICLE) == IsVehicle());
 
    LOG_DEBUG("entities.unit", "SetCharmedBy: charmer {} ({}), charmed {} ({}), type {}.",
        charmer->GetEntry(), charmer->GetGUID().ToString(), GetEntry(), GetGUID().ToString(), uint32(type));
 
    if (this == charmer)
    {
        LOG_FATAL("entities.unit", "Unit::SetCharmedBy: Unit {} ({}) is trying to charm itself!", GetEntry(), GetGUID().ToString());
        return false;
    }
 
    //if (HasUnitState(UNIT_STATE_UNATTACKABLE))
    //    return false;
 
    if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetTransport())
    {
        LOG_FATAL("entities.unit", "Unit::SetCharmedBy: Player on transport is trying to charm {} ({})", GetEntry(), GetGUID().ToString());
        return false;
    }
 
    // Already charmed
    if (GetCharmerGUID())
    {
        LOG_FATAL("entities.unit", "Unit::SetCharmedBy: {} ({}) has already been charmed but {} ({}) is trying to charm it!",
            GetEntry(), GetGUID().ToString(), charmer->GetEntry(), charmer->GetGUID().ToString());
        return false;
    }
 
    CastStop();
    AttackStop();
 
    // Xinef: dont reset threat and combat, put them on offline list, moved down after faction changes
    //  CombatStop(); // TODO: CombatStop(true) may cause crash (interrupt spells)
    //  DeleteThreatList();
 
    Player* playerCharmer = charmer->ToPlayer();
 
    // Charmer stop charming
    if (playerCharmer)
    {
        playerCharmer->StopCastingCharm();
        playerCharmer->StopCastingBindSight();
    }
 
    // Charmed stop charming
    if (GetTypeId() == TYPEID_PLAYER)
    {
        ToPlayer()->StopCastingCharm();
        ToPlayer()->StopCastingBindSight();
    }
 
    // StopCastingCharm may remove a possessed pet?
    if (!IsInWorld())
    {
        LOG_FATAL("entities.unit", "Unit::SetCharmedBy: {} ({}) is not in world but {} ({}) is trying to charm it!",
            GetEntry(), GetGUID().ToString(), charmer->GetEntry(), charmer->GetGUID().ToString());
        return false;
    }
 
    // charm is set by aura, and aura effect remove handler was called during apply handler execution
    // prevent undefined behaviour
    if (aurApp && aurApp->GetRemoveMode())
        return false;
 
    _oldFactionId = GetFaction();
    SetFaction(charmer->GetFaction());
 
    // Set charmed
    charmer->SetCharm(this, true);
 
    StopAttackingInvalidTarget();
 
    if (GetTypeId() == TYPEID_UNIT)
    {
        GetMotionMaster()->Clear(false);
        GetMotionMaster()->MoveIdle();
        StopMoving();
 
        if (charmer->GetTypeId() == TYPEID_PLAYER && charmer->getClass() == CLASS_WARLOCK && ToCreature()->GetCreatureTemplate()->type == CREATURE_TYPE_DEMON)
        {
            // Disable CreatureAI/SmartAI and switch to CharmAI when charmed by warlock
            Creature* charmed = ToCreature();
            charmed->NeedChangeAI = true;
            charmed->IsAIEnabled = false;
        }
        else
        {
            ToCreature()->AI()->OnCharmed(true);
        }
 
        // Xinef: If creature can fly, add normal player flying flag (fixes speed)
        if (charmer->GetTypeId() == TYPEID_PLAYER && ToCreature()->CanFly())
            AddUnitMovementFlag(MOVEMENTFLAG_FLYING);
    }
    else
    {
        Player* player = ToPlayer();
        if (player->isAFK())
            player->ToggleAFK();
 
        player->SetClientControl(this, false); // verified
    }
 
    // charm is set by aura, and aura effect remove handler was called during apply handler execution
    // prevent undefined behaviour
    if (aurApp && aurApp->GetRemoveMode())
        return false;
 
    // Pets already have a properly initialized CharmInfo, don't overwrite it.
    // Xinef: I need charmInfo for vehicle
    if (/*type != CHARM_TYPE_VEHICLE &&*/ !GetCharmInfo())
    {
        InitCharmInfo();
        if (type == CHARM_TYPE_POSSESS)
            GetCharmInfo()->InitPossessCreateSpells();
        else if (type != CHARM_TYPE_VEHICLE)
        {
            GetCharmInfo()->InitCharmCreateSpells();
 
            // Xinef: convert charm npcs dont have pet bar so initialize them as defensive helpers
            if (type == CHARM_TYPE_CONVERT && GetTypeId() == TYPEID_UNIT)
                ToCreature()->SetReactState(REACT_DEFENSIVE);
        }
    }
 
    if (playerCharmer)
    {
        switch (type)
        {
            case CHARM_TYPE_VEHICLE:
                SetUnitFlag(UNIT_FLAG_POSSESSED);
                AddUnitState(UNIT_STATE_NO_ENVIRONMENT_UPD);
                playerCharmer->SetClientControl(this, true); // verified
                playerCharmer->VehicleSpellInitialize();
                break;
            case CHARM_TYPE_POSSESS:
                AddUnitState(UNIT_STATE_POSSESSED);
                AddUnitState(UNIT_STATE_NO_ENVIRONMENT_UPD);
                SetUnitFlag(UNIT_FLAG_POSSESSED);
                charmer->SetUnitFlag(UNIT_FLAG_DISABLE_MOVE);
                playerCharmer->SetClientControl(this, true); // verified
                playerCharmer->PossessSpellInitialize();
                break;
            case CHARM_TYPE_CHARM:
                if (GetTypeId() == TYPEID_UNIT && charmer->getClass() == CLASS_WARLOCK)
                {
                    CreatureTemplate const* cinfo = ToCreature()->GetCreatureTemplate();
                    if (cinfo && cinfo->type == CREATURE_TYPE_DEMON)
                    {
                        // to prevent client crash
                        SetByteValue(UNIT_FIELD_BYTES_0, 1, (uint8)CLASS_MAGE);
 
                        // just to enable stat window
                        if (GetCharmInfo())
                            GetCharmInfo()->SetPetNumber(sObjectMgr->GeneratePetNumber(), true);
 
                        // if charmed two demons the same session, the 2nd gets the 1st one's name
                        SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, uint32(GameTime::GetGameTime().count())); // cast can't be helped
                    }
                }
                GetMotionMaster()->MoveFollow(charmer, PET_FOLLOW_DIST, GetFollowAngle());
                playerCharmer->CharmSpellInitialize();
                break;
            default:
                break;
        }
    }
    else if (GetTypeId() == TYPEID_PLAYER)
        RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT);
 
    if (Creature* creature = ToCreature())
        creature->RefreshSwimmingFlag();
 
    if (GetTypeId() == TYPEID_PLAYER)
        sScriptMgr->OnPlayerBeingCharmed(ToPlayer(), charmer, _oldFactionId, charmer->GetFaction());
 
    return true;
}

◆ SetCharmerGUID()

void Unit::SetCharmerGUID ( ObjectGuid owner )

inline

Definition at line 1818 of file Unit.h.

1818{ SetGuidValue(UNIT_FIELD_CHARMEDBY, owner); }

◆ SetCombatTimer()

void Unit::SetCombatTimer ( uint32 timer )

inline

Definition at line 1696 of file Unit.h.

1696{ m_CombatTimer = timer; }

◆ SetConfused()

void Unit::SetConfused ( bool apply )

protected

Definition at line 18348 of file Unit.cpp.

{
    if (apply)
    {
        SetTarget();
        GetMotionMaster()->MoveConfused();
 
        if (GetTypeId() == TYPEID_PLAYER)
        {
            sScriptMgr->AnticheatSetSkipOnePacketForASH(ToPlayer(), true);
        }
    }
    else
    {
        if (IsAlive())
        {
            if (GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_CONTROLLED) == CONFUSED_MOTION_TYPE)
            {
                GetMotionMaster()->MovementExpired();
                StopMoving();
            }
 
            if (GetVictim())
                SetTarget(GetVictim()->GetGUID());
        }
    }
 
    // xinef: block / allow control to real mover (eg. charmer)
    if (GetTypeId() == TYPEID_PLAYER)
    {
        if (m_movedByPlayer)
            m_movedByPlayer->ToPlayer()->SetClientControl(this, !apply); // verified
        //else
        //  ToPlayer()->SetClientControl(this, !apply);
    }
}

◆ SetContestedPvP()

void Unit::SetContestedPvP	(	Player *	attackedPlayer = `nullptr`,
		bool	lookForNearContestedGuards = `true`
	)

Definition at line 17309 of file Unit.cpp.

{
    Player* player = GetCharmerOrOwnerPlayerOrPlayerItself();
 
    if (!player || ((attackedPlayer && (attackedPlayer == player || (player->duel && player->duel->Opponent == attackedPlayer))) || player->InBattleground()))
        return;
 
    // check if there any guards that should care about the contested flag on player
    if (lookForNearContestedGuards)
    {
        std::list<Unit*> targets;
        Acore::NearestVisibleDetectableContestedGuardUnitCheck u_check(this);
        Acore::UnitListSearcher<Acore::NearestVisibleDetectableContestedGuardUnitCheck> searcher(this, targets, u_check);
        Cell::VisitAllObjects(this, searcher, MAX_AGGRO_RADIUS);
 
        // return if there are no contested guards found
        if (!targets.size())
        {
            return;
        }
    }
 
    player->SetContestedPvPTimer(30000);
    if (!player->HasUnitState(UNIT_STATE_ATTACK_PLAYER))
    {
        player->AddUnitState(UNIT_STATE_ATTACK_PLAYER);
        player->SetPlayerFlag(PLAYER_FLAGS_CONTESTED_PVP);
        // call MoveInLineOfSight for nearby contested guards
        AddToNotify(NOTIFY_AI_RELOCATION);
    }
    if (!HasUnitState(UNIT_STATE_ATTACK_PLAYER))
    {
        AddUnitState(UNIT_STATE_ATTACK_PLAYER);
        // call MoveInLineOfSight for nearby contested guards
        AddToNotify(NOTIFY_AI_RELOCATION);
    }
}

◆ SetControlled()

void Unit::SetControlled	(	bool	apply,
		UnitState	state
	)

Definition at line 18071 of file Unit.cpp.

{
    if (apply)
    {
        if (HasUnitState(state))
            return;
 
        AddUnitState(state);
        switch (state)
        {
            case UNIT_STATE_STUNNED:
                SetStunned(true);
                break;
            case UNIT_STATE_ROOT:
                if (!HasUnitState(UNIT_STATE_STUNNED))
                    SetRooted(true);
                break;
            case UNIT_STATE_CONFUSED:
                if (!HasUnitState(UNIT_STATE_STUNNED))
                {
                    ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
                    SendMeleeAttackStop();
                    // SendAutoRepeatCancel ?
                    SetConfused(true);
                    CastStop(0, false);
                }
                break;
            case UNIT_STATE_FLEEING:
                if (!HasUnitState(UNIT_STATE_STUNNED | UNIT_STATE_CONFUSED))
                {
                    ClearUnitState(UNIT_STATE_MELEE_ATTACKING);
                    SendMeleeAttackStop();
                    // SendAutoRepeatCancel ?
                    SetFeared(true);
                    CastStop(0, false);
                }
                break;
            default:
                break;
        }
 
        if (GetTypeId() == TYPEID_PLAYER)
        {
            sScriptMgr->AnticheatSetRootACKUpd(ToPlayer());
        }
    }
    else
    {
        // xinef: moved from below, checked all SetX functions, no calls to currently modified state
        // xinef: added to each case because of return
        //ClearUnitState(state);
 
        switch (state)
        {
            case UNIT_STATE_STUNNED:
                if (HasAuraType(SPELL_AURA_MOD_STUN))
                    return;
                ClearUnitState(state);
                SetStunned(false);
                break;
            case UNIT_STATE_ROOT:
                // Prevent creature_template_movement rooted flag from being removed on aura expiration.
                if (GetTypeId() == TYPEID_UNIT)
                {
                    if (ToCreature()->GetCreatureTemplate()->Movement.Rooted)
                    {
                        return;
                    }
                }
 
                if (HasAuraType(SPELL_AURA_MOD_ROOT) || GetVehicle())
                    return;
                ClearUnitState(state);
                SetRooted(false);
                break;
            case UNIT_STATE_CONFUSED:
                if (HasAuraType(SPELL_AURA_MOD_CONFUSE))
                    return;
                ClearUnitState(state);
                SetConfused(false);
                break;
            case UNIT_STATE_FLEEING:
                if (HasAuraType(SPELL_AURA_MOD_FEAR))
                    return;
                ClearUnitState(state);
                SetFeared(false);
                break;
            default:
                return;
        }
 
        //ClearUnitState(state);
 
        if (HasUnitState(UNIT_STATE_STUNNED) || HasAuraType(SPELL_AURA_MOD_STUN))
            SetStunned(true);
        else
        {
            if (HasUnitState(UNIT_STATE_ROOT) || HasAuraType(SPELL_AURA_MOD_ROOT))
                SetRooted(true);
 
            if (HasUnitState(UNIT_STATE_CONFUSED) || HasAuraType(SPELL_AURA_MOD_CONFUSE))
                SetConfused(true);
            else if (HasUnitState(UNIT_STATE_FLEEING) || HasAuraType(SPELL_AURA_MOD_FEAR))
                SetFeared(true);
        }
    }
}

◆ SetCreateHealth()

void Unit::SetCreateHealth ( uint32 val )

inline

Definition at line 2035 of file Unit.h.

2035{ SetUInt32Value(UNIT_FIELD_BASE_HEALTH, val); }

◆ SetCreateMana()

void Unit::SetCreateMana ( uint32 val )

inline

Definition at line 2037 of file Unit.h.

2037{ SetUInt32Value(UNIT_FIELD_BASE_MANA, val); }

◆ SetCreateStat()

void Unit::SetCreateStat	(	Stats	stat,
		float	val
	)

inline

Definition at line 2034 of file Unit.h.

2034{ m_createStats[stat] = val; }

◆ SetCreatorGUID()

void Unit::SetCreatorGUID ( ObjectGuid creator )

inline

Definition at line 1814 of file Unit.h.

1814{ SetGuidValue(UNIT_FIELD_CREATEDBY, creator); }

◆ SetCritterGUID()

void Unit::SetCritterGUID ( ObjectGuid guid )

inline

Definition at line 1822 of file Unit.h.

1822{ SetGuidValue(UNIT_FIELD_CRITTER, guid); }

◆ SetCurrentCastedSpell()

void Unit::SetCurrentCastedSpell ( Spell * pSpell )

Definition at line 3897 of file Unit.cpp.

{
    ASSERT(pSpell);                                         // nullptr may be never passed here, use InterruptSpell or InterruptNonMeleeSpells
 
    CurrentSpellTypes CSpellType = pSpell->GetCurrentContainer();
 
    if (pSpell == m_currentSpells[CSpellType])             // avoid breaking self
        return;
 
    bool bySelf = m_currentSpells[CSpellType] && m_currentSpells[CSpellType]->m_spellInfo->Id == pSpell->m_spellInfo->Id;
 
    // break same type spell if it is not delayed
    InterruptSpell(CSpellType, false, true, bySelf);
 
    // special breakage effects:
    switch (CSpellType)
    {
        case CURRENT_GENERIC_SPELL:
            {
                // generic spells always break channeled not delayed spells
                if (Spell* s = GetCurrentSpell(CURRENT_CHANNELED_SPELL))
                {
                    if (!s->GetSpellInfo()->IsActionAllowedChannel())
                    {
                        InterruptSpell(CURRENT_CHANNELED_SPELL, false);
                    }
                }
 
                // autorepeat breaking
                if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL])
                {
                    // break autorepeat if not Auto Shot
                    if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id != 75)
                        InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
                    m_AutoRepeatFirstCast = true;
                }
                if (pSpell->GetCastTime() > 0)
                    AddUnitState(UNIT_STATE_CASTING);
 
                break;
            }
        case CURRENT_CHANNELED_SPELL:
            {
                // channel spells always break generic non-delayed and any channeled spells
                InterruptSpell(CURRENT_GENERIC_SPELL, false);
                InterruptSpell(CURRENT_CHANNELED_SPELL, true, true, bySelf);
 
                // it also does break autorepeat if not Auto Shot
                if (m_currentSpells[CURRENT_AUTOREPEAT_SPELL] &&
                        m_currentSpells[CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id != 75)
                    InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
                AddUnitState(UNIT_STATE_CASTING);
 
                break;
            }
        case CURRENT_AUTOREPEAT_SPELL:
            {
                // only Auto Shoot does not break anything
                if (pSpell->m_spellInfo->Id != 75)
                {
                    // generic autorepeats break generic non-delayed and channeled non-delayed spells
                    if (Spell* s = GetCurrentSpell(CURRENT_CHANNELED_SPELL))
                    {
                        if (!s->GetSpellInfo()->IsActionAllowedChannel())
                        {
                            InterruptSpell(CURRENT_CHANNELED_SPELL, false);
                        }
                    }
 
                    InterruptSpell(CURRENT_CHANNELED_SPELL, false);
                }
                // special action: set first cast flag
                m_AutoRepeatFirstCast = true;
 
                break;
            }
 
        default:
            // other spell types don't break anything now
            break;
    }
 
    // current spell (if it is still here) may be safely deleted now
    if (m_currentSpells[CSpellType])
        m_currentSpells[CSpellType]->SetReferencedFromCurrent(false);
 
    // set new current spell
    m_currentSpells[CSpellType] = pSpell;
    pSpell->SetReferencedFromCurrent(true);
 
    pSpell->m_selfContainer = &(m_currentSpells[pSpell->GetCurrentContainer()]);
}

◆ setDeathState()

void Unit::setDeathState	(	DeathState	s,
		bool	despawn = `false`
	)

virtual

Reimplemented in Creature, Minion, Pet, and Player.

Definition at line 14425 of file Unit.cpp.

{
    // death state needs to be updated before RemoveAllAurasOnDeath() calls HandleChannelDeathItem(..) so that
    // it can be used to check creation of death items (such as soul shards).
 
    if (s != ALIVE && s != JUST_RESPAWNED)
    {
        CombatStop();
        GetThreatMgr().ClearAllThreat();
        getHostileRefMgr().deleteReferences();
        ClearComboPointHolders();                           // any combo points pointed to unit lost at it death
 
        if (IsNonMeleeSpellCast(false))
            InterruptNonMeleeSpells(false);
 
        UnsummonAllTotems(true);
        RemoveAllControlled(true);
        RemoveAllAurasOnDeath();
    }
 
    if (s == JUST_DIED)
    {
        // remove aurastates allowing special moves
        ClearAllReactives();
        ClearDiminishings();
 
        GetMotionMaster()->Clear(false);
        GetMotionMaster()->MoveIdle();
 
        // Xinef: Remove Hover so the corpse can fall to the ground
        SetHover(false);
 
        if (despawn)
            DisableSpline();
        else
            StopMoving();
 
        // without this when removing IncreaseMaxHealth aura player may stuck with 1 hp
        // do not why since in IncreaseMaxHealth currenthealth is checked
        SetHealth(0);
        SetPower(getPowerType(), 0);
 
        // players in instance don't have ZoneScript, but they have InstanceScript
        if (ZoneScript* zoneScript = GetZoneScript() ? GetZoneScript() : (ZoneScript*)GetInstanceScript())
            zoneScript->OnUnitDeath(this);
    }
    else if (s == JUST_RESPAWNED)
    {
        RemoveFlag (UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE); // clear skinnable for creature and player (at battleground)
    }
 
    m_deathState = s;
}

◆ SetDisableGravity()

bool Unit::SetDisableGravity	(	bool	disable,
		bool	packetOnly = `false`,
		bool	updateAnimationTier = `true`
	)

virtual

Reimplemented in Creature, and Player.

Definition at line 20656 of file Unit.cpp.

{
    if (disable == IsLevitating())
        return false;
 
    if (disable)
    {
        AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
        RemoveUnitMovementFlag(MOVEMENTFLAG_FALLING);
    }
    else
    {
        RemoveUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
    }
 
    return true;
}

◆ SetDisplayId()

void Unit::SetDisplayId ( uint32 modelId )

virtual

Reimplemented in Creature, and Pet.

Definition at line 16840 of file Unit.cpp.

{
    SetUInt32Value(UNIT_FIELD_DISPLAYID, modelId);
    // Set Gender by modelId
    if (CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelInfo(modelId))
        SetByteValue(UNIT_FIELD_BYTES_0, 2, minfo->gender);
 
    sScriptMgr->OnDisplayIdChange(this, modelId);
}

◆ SetExtraUnitMovementFlags()

void Unit::SetExtraUnitMovementFlags ( uint16 f )

inline

Definition at line 2277 of file Unit.h.

2277{ m_movementInfo.flags2 = f; }

◆ SetFacingTo()

void Unit::SetFacingTo ( float ori )

Definition at line 20619 of file Unit.cpp.

{
    Movement::MoveSplineInit init(this);
    init.MoveTo(GetPositionX(), GetPositionY(), GetPositionZ(), false);
    if (HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) && GetTransGUID())
        init.DisableTransportPathTransformations(); // It makes no sense to target global orientation
    init.SetFacing(ori);
    init.Launch();
}

◆ SetFacingToObject()

void Unit::SetFacingToObject ( WorldObject * object )

Todo:: figure out under what conditions creature will move towards object instead of facing it where it currently is.

Definition at line 20629 of file Unit.cpp.

{
    // never face when already moving
    if (!IsStopped())
        return;
 
    Movement::MoveSplineInit init(this);
    init.MoveTo(GetPositionX(), GetPositionY(), GetPositionZ());
    init.SetFacing(GetAngle(object));   // when on transport, GetAngle will still return global coordinates (and angle) that needs transforming
    init.Launch();
}

◆ SetFaction()

void Unit::SetFaction ( uint32 faction )

Definition at line 10017 of file Unit.cpp.

{
    SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, faction);
    if (GetTypeId() == TYPEID_UNIT)
        ToCreature()->UpdateMoveInLineOfSightState();
}

◆ SetFeared()

void Unit::SetFeared ( bool apply )

protected

Definition at line 18304 of file Unit.cpp.

{
    if (apply)
    {
        SetTarget();
 
        Unit* caster = nullptr;
        Unit::AuraEffectList const& fearAuras = GetAuraEffectsByType(SPELL_AURA_MOD_FEAR);
        if (!fearAuras.empty())
            caster = ObjectAccessor::GetUnit(*this, fearAuras.front()->GetCasterGUID());
        if (!caster)
            caster = getAttackerForHelper();
        GetMotionMaster()->MoveFleeing(caster, fearAuras.empty() ? sWorld->getIntConfig(CONFIG_CREATURE_FAMILY_FLEE_DELAY) : 0);             // caster == nullptr processed in MoveFleeing
 
        if (GetTypeId() == TYPEID_PLAYER)
        {
            sScriptMgr->AnticheatSetSkipOnePacketForASH(ToPlayer(), true);
        }
    }
    else
    {
        if (IsAlive())
        {
            if (GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_CONTROLLED) == FLEEING_MOTION_TYPE)
            {
                GetMotionMaster()->MovementExpired();
                StopMoving();
            }
 
            if (GetVictim())
                SetTarget(GetVictim()->GetGUID());
        }
    }
 
    // xinef: block / allow control to real mover (eg. charmer)
    if (GetTypeId() == TYPEID_PLAYER)
    {
        if (m_movedByPlayer)
            m_movedByPlayer->ToPlayer()->SetClientControl(this, !apply); // verified
        //else
        //  ToPlayer()->SetClientControl(this, !apply);
    }
}

◆ SetFeatherFall()

bool Unit::SetFeatherFall	(	bool	enable,
		bool	packetOnly = `false`
	)

virtual

Reimplemented in Player, and Creature.

Definition at line 20733 of file Unit.cpp.

{
    if (enable == HasUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW))
        return false;
 
    if (enable)
        AddUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
    else
        RemoveUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
 
    return true;
}

◆ SetFullHealth()

void Unit::SetFullHealth ( )

inline

Definition at line 1453 of file Unit.h.

1453{ SetHealth(GetMaxHealth()); }

◆ SetHealth()

void Unit::SetHealth ( uint32 val )

Definition at line 15335 of file Unit.cpp.

{
    if (getDeathState() == JUST_DIED)
        val = 0;
    else if (GetTypeId() == TYPEID_PLAYER && getDeathState() == DEAD)
        val = 1;
    else
    {
        uint32 maxHealth = GetMaxHealth();
        if (maxHealth < val)
            val = maxHealth;
    }
 
    float prevHealthPct = GetHealthPct();
 
    SetUInt32Value(UNIT_FIELD_HEALTH, val);
 
    // mobs that are now or were below 30% need to update their speed
    if (GetTypeId() == TYPEID_UNIT && (prevHealthPct < 30.0 || HealthBelowPct(30)))
    {
        UpdateSpeed(MOVE_RUN, false);
    }
 
    // group update
    if (GetTypeId() == TYPEID_PLAYER)
    {
        Player* player = ToPlayer();
        if (player->NeedSendSpectatorData())
            ArenaSpectator::SendCommand_UInt32Value(FindMap(), GetGUID(), "CHP", val);
 
        if (player->GetGroup())
            player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_CUR_HP);
    }
    else if (Pet* pet = ToCreature()->ToPet())
    {
        if (pet->isControlled())
        {
            if (Unit* owner = GetOwner())
                if (Player* player = owner->ToPlayer())
                {
                    if (player->NeedSendSpectatorData() && pet->GetCreatureTemplate()->family)
                        ArenaSpectator::SendCommand_UInt32Value(player->FindMap(), player->GetGUID(), "PHP", (uint32)pet->GetHealthPct());
 
                    if (player->GetGroup())
                        player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_CUR_HP);
                }
        }
    }
}

◆ SetHover()

bool Unit::SetHover	(	bool	enable,
		bool	packetOnly = `false`,
		bool	updateAnimationTier = `true`
	)

virtual

Reimplemented in Creature, and Player.

Definition at line 20755 of file Unit.cpp.

{
    if (enable == HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
        return false;
 
    float hoverHeight = GetFloatValue(UNIT_FIELD_HOVERHEIGHT);
 
    if (enable)
    {
        AddUnitMovementFlag(MOVEMENTFLAG_HOVER);
        if (hoverHeight && GetPositionZ() - GetFloorZ() < hoverHeight)
            UpdateHeight(GetPositionZ() + hoverHeight);
    }
    else
    {
        RemoveUnitMovementFlag(MOVEMENTFLAG_HOVER);
        if (hoverHeight && (!isDying() || GetTypeId() != TYPEID_UNIT))
        {
            float newZ = std::max<float>(GetFloorZ(), GetPositionZ() - hoverHeight);
            UpdateAllowedPositionZ(GetPositionX(), GetPositionY(), newZ);
            UpdateHeight(newZ);
        }
        SendMovementFlagUpdate(); // pussywizard: needed for falling after death (instead of falling onto air at hover height)
    }
 
    return true;
}

◆ SetImmuneToAll()

void Unit::SetImmuneToAll	(	bool	apply,
		bool	keepCombat = `false`
	)

inline

Definition at line 1675 of file Unit.h.

1675{ SetImmuneToPC(apply, keepCombat); SetImmuneToNPC(apply, keepCombat); }

Unit::SetImmuneToNPC

void SetImmuneToNPC(bool apply, bool keepCombat=false)

Definition: Unit.cpp:13520

◆ SetImmuneToNPC()

void Unit::SetImmuneToNPC	(	bool	apply,
		bool	keepCombat = `false`
	)

Definition at line 13520 of file Unit.cpp.

{
    (void)keepCombat;
    if (apply)
        SetUnitFlag(UNIT_FLAG_IMMUNE_TO_NPC);
    else
        RemoveUnitFlag(UNIT_FLAG_IMMUNE_TO_NPC);
}

◆ SetImmuneToPC()

void Unit::SetImmuneToPC	(	bool	apply,
		bool	keepCombat = `false`
	)

Definition at line 13511 of file Unit.cpp.

{
    (void)keepCombat;
    if (apply)
        SetUnitFlag(UNIT_FLAG_IMMUNE_TO_PC);
    else
        RemoveUnitFlag(UNIT_FLAG_IMMUNE_TO_PC);
}

◆ SetInCombatState()

void Unit::SetInCombatState	(	bool	PvP,
		Unit *	enemy = `nullptr`,
		uint32	duration = `0`
	)

Definition at line 13627 of file Unit.cpp.

{
    // only alive units can be in combat
    if (!IsAlive())
        return;
 
    if (PvP)
        m_CombatTimer = std::max<uint32>(GetCombatTimer(), std::max<uint32>(5500, duration));
    else if (duration)
        m_CombatTimer = std::max<uint32>(GetCombatTimer(), duration);
 
    if (HasUnitState(UNIT_STATE_EVADE) || GetCreatureType() == CREATURE_TYPE_NON_COMBAT_PET)
        return;
 
    // xinef: if we somehow engage in combat (scripts, dunno) with player, remove this flag so he can fight back
    if (GetTypeId() == TYPEID_UNIT && enemy && IsImmuneToPC() && enemy->GetCharmerOrOwnerPlayerOrPlayerItself())
        SetImmuneToPC(false); // unit has engaged in combat, remove immunity so players can fight back
 
    if (IsInCombat())
        return;
 
    SetUnitFlag(UNIT_FLAG_IN_COMBAT);
 
    if (Creature* creature = ToCreature())
    {
        // Set home position at place of engaging combat for escorted creatures
        if ((IsAIEnabled && creature->AI()->IsEscorted()) ||
                GetMotionMaster()->GetCurrentMovementGeneratorType() == WAYPOINT_MOTION_TYPE ||
                GetMotionMaster()->GetCurrentMovementGeneratorType() == ESCORT_MOTION_TYPE)
            creature->SetHomePosition(GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation());
 
        if (enemy)
        {
            if (IsAIEnabled)
                creature->AI()->EnterCombat(enemy);
 
            if (creature->GetFormation())
                creature->GetFormation()->MemberEngagingTarget(creature, enemy);
 
            sScriptMgr->OnUnitEnterCombat(creature, enemy);
        }
 
        creature->RefreshSwimmingFlag();
 
        if (IsPet())
        {
            UpdateSpeed(MOVE_RUN, true);
            UpdateSpeed(MOVE_SWIM, true);
            UpdateSpeed(MOVE_FLIGHT, true);
        }
 
        if (!(creature->GetCreatureTemplate()->type_flags & CREATURE_TYPE_FLAG_ALLOW_MOUNTED_COMBAT))
            Dismount();
        if (!IsStandState()) // pussywizard: already done in CombatStart(target, initialAggro) for the target, but when aggro'ing from MoveInLOS CombatStart is not called!
            SetStandState(UNIT_STAND_STATE_STAND);
    }
 
    for (Unit::ControlSet::iterator itr = m_Controlled.begin(); itr != m_Controlled.end();)
    {
        Unit* controlled = *itr;
        ++itr;
 
        // Xinef: Dont set combat for passive units, they will evade in next update...
        if (controlled->GetTypeId() == TYPEID_UNIT && controlled->ToCreature()->HasReactState(REACT_PASSIVE))
            continue;
 
        controlled->SetInCombatState(PvP, enemy, duration);
    }
 
    if (Player* player = this->ToPlayer())
    {
        sScriptMgr->OnPlayerEnterCombat(player, enemy);
    }
}

◆ SetInCombatWith()

void Unit::SetInCombatWith	(	Unit *	enemy,
		uint32	duration = `0`
	)

Definition at line 13485 of file Unit.cpp.

{
    // Xinef: Dont allow to start combat with triggers
    if (enemy->GetTypeId() == TYPEID_UNIT && enemy->ToCreature()->IsTrigger())
        return;
 
    Unit* eOwner = enemy->GetCharmerOrOwnerOrSelf();
    if (eOwner->IsPvP() || eOwner->IsFFAPvP())
    {
        SetInCombatState(true, enemy, duration);
        return;
    }
 
    // check for duel
    if (eOwner->GetTypeId() == TYPEID_PLAYER && eOwner->ToPlayer()->duel)
    {
        Unit const* myOwner = GetCharmerOrOwnerOrSelf();
        if (((Player const*)eOwner)->duel->Opponent == myOwner)
        {
            SetInCombatState(true, enemy, duration);
            return;
        }
    }
    SetInCombatState(false, enemy, duration);
}

◆ SetInFront()

void Unit::SetInFront ( WorldObject const * target )

Definition at line 20613 of file Unit.cpp.

{
    if (!HasUnitState(UNIT_STATE_CANNOT_TURN))
        SetOrientation(GetAngle(target));
}

◆ SetInstantCast()

void Unit::SetInstantCast ( bool set )

inline

Definition at line 2431 of file Unit.h.

2431{ _instantCast = set; }

◆ SetLastDamagedTargetGuid()

void Unit::SetLastDamagedTargetGuid ( ObjectGuid const & guid )

inline

Definition at line 1569 of file Unit.h.

1569{ _lastDamagedTargetGuid = guid; }

◆ SetLastExtraAttackSpell()

void Unit::SetLastExtraAttackSpell ( uint32 spellId )

inline

Definition at line 1566 of file Unit.h.

1566{ _lastExtraAttackSpell = spellId; }

◆ SetLastManaUse()

void Unit::SetLastManaUse ( uint32 spellCastTime )

inline

Definition at line 2212 of file Unit.h.

2212{ m_lastManaUse = spellCastTime; }

◆ SetLevel()

void Unit::SetLevel	(	uint8	lvl,
		bool	showLevelChange = `true`
	)

Definition at line 15317 of file Unit.cpp.

{
    SetUInt32Value(UNIT_FIELD_LEVEL, lvl);
 
    // Xinef: unmark field bit update
    if (!showLevelChange)
        _changesMask.UnsetBit(UNIT_FIELD_LEVEL);
 
    // group update
    if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetGroup())
        ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_LEVEL);
 
    if (GetTypeId() == TYPEID_PLAYER)
    {
        sCharacterCache->UpdateCharacterLevel(GetGUID(), lvl);
    }
}

◆ SetMaxHealth()

void Unit::SetMaxHealth ( uint32 val )

Definition at line 15385 of file Unit.cpp.

{
    if (!val)
        val = 1;
 
    uint32 health = GetHealth();
    SetUInt32Value(UNIT_FIELD_MAXHEALTH, val);
 
    // group update
    if (GetTypeId() == TYPEID_PLAYER)
    {
        Player* player = ToPlayer();
        if (player->NeedSendSpectatorData())
            ArenaSpectator::SendCommand_UInt32Value(FindMap(), GetGUID(), "MHP", val);
 
        if (player->GetGroup())
            player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_MAX_HP);
    }
    else if (Pet* pet = ToCreature()->ToPet())
    {
        if (pet->isControlled())
        {
            if (Unit* owner = GetOwner())
                if (Player* player = owner->ToPlayer())
                {
                    if (player->NeedSendSpectatorData() && pet->GetCreatureTemplate()->family)
                        ArenaSpectator::SendCommand_UInt32Value(player->FindMap(), player->GetGUID(), "PHP", (uint32)pet->GetHealthPct());
 
                    if (player->GetGroup())
                        player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MAX_HP);
                }
        }
    }
 
    if (val < health)
        SetHealth(val);
}

◆ SetMaxPower()

void Unit::SetMaxPower	(	Powers	power,
		uint32	val
	)

Definition at line 15468 of file Unit.cpp.

{
    uint32 cur_power = GetPower(power);
    SetStatInt32Value(static_cast<uint16>(UNIT_FIELD_MAXPOWER1) + power, val);
 
    // group update
    if (GetTypeId() == TYPEID_PLAYER)
    {
        Player* player = ToPlayer();
        if (getPowerType() == power && player->NeedSendSpectatorData())
            ArenaSpectator::SendCommand_UInt32Value(FindMap(), GetGUID(), "MPW", power == POWER_RAGE || power == POWER_RUNIC_POWER ? val / 10 : val);
 
        if (player->GetGroup())
            player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_MAX_POWER);
    }
    else if (Pet* pet = ToCreature()->ToPet())
    {
        if (pet->isControlled())
        {
            Unit* owner = GetOwner();
            if (owner && (owner->GetTypeId() == TYPEID_PLAYER) && owner->ToPlayer()->GetGroup())
                owner->ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MAX_POWER);
        }
    }
 
    if (val < cur_power)
        SetPower(power, val);
}

◆ SetMinion()

void Unit::SetMinion	(	Minion *	minion,
		bool	apply
	)

Definition at line 10628 of file Unit.cpp.

{
    LOG_DEBUG("entities.unit", "SetMinion {} for {}, apply {}", minion->GetEntry(), GetEntry(), apply);
 
    if (apply)
    {
        if (minion->GetOwnerGUID())
        {
            LOG_FATAL("entities.unit", "SetMinion: Minion {} is not the minion of owner {}", minion->GetEntry(), GetEntry());
            return;
        }
 
        minion->SetOwnerGUID(GetGUID());
 
        m_Controlled.insert(minion);
 
        if (GetTypeId() == TYPEID_PLAYER)
        {
            minion->m_ControlledByPlayer = true;
            minion->SetUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED);
        }
 
        // Can only have one pet. If a new one is summoned, dismiss the old one.
        if (minion->IsGuardianPet())
        {
            if (Guardian* oldPet = GetGuardianPet())
            {
                if (oldPet != minion && (oldPet->IsPet() || minion->IsPet() || oldPet->GetEntry() != minion->GetEntry()))
                {
                    // remove existing minion pet
                    if (Pet* oldPetAsPet = oldPet->ToPet())
                    {
                        oldPetAsPet->Remove(PET_SAVE_NOT_IN_SLOT);
                    }
                    else
                    {
                        oldPet->UnSummon();
                    }
 
                    SetPetGUID(minion->GetGUID());
                    SetMinionGUID(ObjectGuid::Empty);
                }
            }
            else
            {
                SetPetGUID(minion->GetGUID());
                SetMinionGUID(ObjectGuid::Empty);
            }
        }
 
        if (minion->HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN))
        {
            AddGuidValue(UNIT_FIELD_SUMMON, minion->GetGUID());
        }
 
        if (minion->m_Properties && minion->m_Properties->Type == SUMMON_TYPE_MINIPET)
        {
            SetCritterGUID(minion->GetGUID());
        }
 
        // PvP, FFAPvP
        minion->SetByteValue(UNIT_FIELD_BYTES_2, 1, GetByteValue(UNIT_FIELD_BYTES_2, 1));
 
        // FIXME: hack, speed must be set only at follow
        if (GetTypeId() == TYPEID_PLAYER && minion->IsPet())
            for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
                minion->SetSpeed(UnitMoveType(i), m_speed_rate[i], true);
 
        // Ghoul pets have energy instead of mana (is anywhere better place for this code?)
        if (minion->IsPetGhoul() || minion->GetEntry() == 24207 /*ENTRY_ARMY_OF_THE_DEAD*/)
            minion->setPowerType(POWER_ENERGY);
 
        if (GetTypeId() == TYPEID_PLAYER)
        {
            // Send infinity cooldown - client does that automatically but after relog cooldown needs to be set again
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(minion->GetUInt32Value(UNIT_CREATED_BY_SPELL));
 
            if (spellInfo && spellInfo->IsCooldownStartedOnEvent())
                ToPlayer()->AddSpellAndCategoryCooldowns(spellInfo, 0, nullptr, true);
        }
    }
    else
    {
        if (minion->GetOwnerGUID() != GetGUID())
        {
            LOG_FATAL("entities.unit", "SetMinion: Minion {} is not the minion of owner {}", minion->GetEntry(), GetEntry());
            return;
        }
 
        m_Controlled.erase(minion);
 
        if (minion->m_Properties && minion->m_Properties->Type == SUMMON_TYPE_MINIPET)
        {
            if (GetCritterGUID() == minion->GetGUID())
                SetCritterGUID(ObjectGuid::Empty);
        }
 
        if (minion->IsGuardianPet())
        {
            if (GetPetGUID() == minion->GetGUID())
                SetPetGUID(ObjectGuid::Empty);
        }
        else if (minion->IsTotem())
        {
            // All summoned by totem minions must disappear when it is removed.
            if (SpellInfo const* spInfo = sSpellMgr->GetSpellInfo(minion->ToTotem()->GetSpell()))
            {
                for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
                {
                    if (spInfo->Effects[i].Effect != SPELL_EFFECT_SUMMON)
                        continue;
 
                    RemoveAllMinionsByEntry(spInfo->Effects[i].MiscValue);
                }
            }
        }
 
        if (GetTypeId() == TYPEID_PLAYER)
        {
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(minion->GetUInt32Value(UNIT_CREATED_BY_SPELL));
            // Remove infinity cooldown
            if (spellInfo && spellInfo->IsCooldownStartedOnEvent())
                ToPlayer()->SendCooldownEvent(spellInfo);
 
            // xinef: clear spell book
            if (m_Controlled.empty())
                ToPlayer()->SendRemoveControlBar();
        }
 
        //if (minion->HasUnitTypeMask(UNIT_MASK_GUARDIAN))
        {
            if (RemoveGuidValue(UNIT_FIELD_SUMMON, minion->GetGUID()))
            {
                // Check if there is another minion
                for (ControlSet::iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
                {
                    // do not use this check, creature do not have charm guid
                    //if (GetCharmGUID() == (*itr)->GetGUID())
                    if (GetGUID() == (*itr)->GetCharmerGUID())
                        continue;
 
                    //ASSERT((*itr)->GetOwnerGUID() == GetGUID());
                    if ((*itr)->GetOwnerGUID() != GetGUID())
                    {
                        OutDebugInfo();
                        (*itr)->OutDebugInfo();
                        ABORT();
                    }
                    ASSERT((*itr)->GetTypeId() == TYPEID_UNIT);
 
                    if (!(*itr)->HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN))
                        continue;
 
                    if (AddGuidValue(UNIT_FIELD_SUMMON, (*itr)->GetGUID()))
                    {
                        // show another pet bar if there is no charm bar
                        if (GetTypeId() == TYPEID_PLAYER && !GetCharmGUID())
                        {
                            if ((*itr)->IsPet())
                                ToPlayer()->PetSpellInitialize();
                            else
                                ToPlayer()->CharmSpellInitialize();
                        }
                    }
                    break;
                }
            }
        }
    }
}

◆ SetMinionGUID()

void Unit::SetMinionGUID ( ObjectGuid guid )

inline

Definition at line 1816 of file Unit.h.

1816{ SetGuidValue(UNIT_FIELD_SUMMON, guid); }

◆ SetModelVisible()

void Unit::SetModelVisible ( bool on )

Definition at line 14127 of file Unit.cpp.

{
    if (on)
        RemoveAurasDueToSpell(24401);
    else
        CastSpell(this, 24401, true);
}

◆ SetModifierValue()

void Unit::SetModifierValue	(	UnitMods	unitMod,
		UnitModifierType	modifierType,
		float	value
	)

inline

Definition at line 2095 of file Unit.h.

2095{ m_auraModifiersGroup[unitMod][modifierType] = value; }

◆ SetNativeDisplayId()

void Unit::SetNativeDisplayId ( uint32 modelId )

inline

Definition at line 2167 of file Unit.h.

2167{ SetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID, modelId); }

◆ SetNpcFlag()

void Unit::SetNpcFlag ( NPCFlags flags )

inline

Definition at line 1644 of file Unit.h.

1644{ SetFlag(UNIT_NPC_FLAGS, flags); }

◆ SetOwnerGUID()

void Unit::SetOwnerGUID ( ObjectGuid owner )

Definition at line 10521 of file Unit.cpp.

{
    if (GetOwnerGUID() == owner)
        return;
 
    SetGuidValue(UNIT_FIELD_SUMMONEDBY, owner);
    if (!owner)
        return;
 
    m_applyResilience = !IsVehicle() && owner.IsPlayer();
 
    // Update owner dependent fields
    Player* player = ObjectAccessor::GetPlayer(*this, owner);
    if (!player || !player->HaveAtClient(this)) // if player cannot see this unit yet, he will receive needed data with create object
        return;
 
    SetFieldNotifyFlag(UF_FLAG_OWNER);
 
    UpdateData udata;
    WorldPacket packet;
    BuildValuesUpdateBlockForPlayer(&udata, player);
    udata.BuildPacket(&packet);
    player->SendDirectMessage(&packet);
 
    RemoveFieldNotifyFlag(UF_FLAG_OWNER);
}

◆ SetPetGUID()

void Unit::SetPetGUID ( ObjectGuid guid )

inline

Definition at line 1820 of file Unit.h.

1820{ m_SummonSlot[SUMMON_SLOT_PET] = guid; }

◆ SetPhaseMask()

void Unit::SetPhaseMask	(	uint32	newPhaseMask,
		bool	update
	)

overridevirtual

Reimplemented from WorldObject.

Definition at line 19081 of file Unit.cpp.

{
    if (newPhaseMask == GetPhaseMask())
        return;
 
    if (IsInWorld())
    {
        // xinef: to comment, bellow line should be removed
        // pussywizard: goign to other phase (valithria, algalon) should not remove such auras
        //RemoveNotOwnSingleTargetAuras(newPhaseMask, true);            // we can lost access to caster or target
 
        if (!sScriptMgr->CanSetPhaseMask(this, newPhaseMask, update))
            return;
 
        // modify hostile references for new phasemask, some special cases deal with hostile references themselves
        if (GetTypeId() == TYPEID_UNIT || (!ToPlayer()->IsGameMaster() && !ToPlayer()->GetSession()->PlayerLogout()))
        {
            HostileRefMgr& refMgr = getHostileRefMgr();
            HostileReference* ref = refMgr.getFirst();
 
            while (ref)
            {
                if (Unit* unit = ref->GetSource()->GetOwner())
                    if (Creature* creature = unit->ToCreature())
                        refMgr.setOnlineOfflineState(creature, creature->InSamePhase(newPhaseMask));
 
                ref = ref->next();
            }
 
            // modify threat lists for new phasemask
            if (GetTypeId() != TYPEID_PLAYER)
            {
                ThreatContainer::StorageType threatList = GetThreatMgr().GetThreatList();
                ThreatContainer::StorageType offlineThreatList = GetThreatMgr().GetOfflineThreatList();
 
                // merge expects sorted lists
                threatList.sort();
                offlineThreatList.sort();
                threatList.merge(offlineThreatList);
 
                for (ThreatContainer::StorageType::const_iterator itr = threatList.begin(); itr != threatList.end(); ++itr)
                    if (Unit* unit = (*itr)->getTarget())
                        unit->getHostileRefMgr().setOnlineOfflineState(ToCreature(), unit->InSamePhase(newPhaseMask));
            }
        }
    }
 
    WorldObject::SetPhaseMask(newPhaseMask, false);
 
    if (!IsInWorld())
    {
        return;
    }
 
    for (ControlSet::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); )
    {
        Unit* controlled = *itr;
        ++itr;
        if (controlled->GetTypeId() == TYPEID_UNIT)
        {
            controlled->SetPhaseMask(newPhaseMask, true);
        }
    }
 
    for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
    {
        if (m_SummonSlot[i])
        {
            if (Creature* summon = GetMap()->GetCreature(m_SummonSlot[i]))
            {
                summon->SetPhaseMask(newPhaseMask, true);
            }
        }
    }
 
    if (update)
    {
        UpdateObjectVisibility();
    }
}

◆ SetPower()

void Unit::SetPower	(	Powers	power,
		uint32	val,
		bool	withPowerUpdate = `true`
	)

Definition at line 15423 of file Unit.cpp.

{
    if (GetPower(power) == val)
        return;
 
    uint32 maxPower = GetMaxPower(power);
    if (maxPower < val)
        val = maxPower;
 
    SetStatInt32Value(static_cast<uint16>(UNIT_FIELD_POWER1) + power, val);
 
    if (withPowerUpdate)
    {
        WorldPacket data(SMSG_POWER_UPDATE);
        data << GetPackGUID();
        data << uint8(power);
        data << uint32(val);
        SendMessageToSet(&data, GetTypeId() == TYPEID_PLAYER);
    }
 
    // group update
    if (GetTypeId() == TYPEID_PLAYER)
    {
        Player* player = ToPlayer();
        if (getPowerType() == power && player->NeedSendSpectatorData())
            ArenaSpectator::SendCommand_UInt32Value(FindMap(), GetGUID(), "CPW", power == POWER_RAGE || power == POWER_RUNIC_POWER ? val / 10 : val);
 
        if (player->GetGroup())
            player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_CUR_POWER);
    }
    else if (Pet* pet = ToCreature()->ToPet())
    {
        if (pet->isControlled())
        {
            Unit* owner = GetOwner();
            if (owner && (owner->GetTypeId() == TYPEID_PLAYER) && owner->ToPlayer()->GetGroup())
                owner->ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_CUR_POWER);
        }
 
        // Update the pet's character sheet with happiness damage bonus
        if (pet->getPetType() == HUNTER_PET && power == POWER_HAPPINESS)
            pet->UpdateDamagePhysical(BASE_ATTACK);
    }
}

◆ setPowerType()

void Unit::setPowerType ( Powers power )

Definition at line 9940 of file Unit.cpp.

{
    SetByteValue(UNIT_FIELD_BYTES_0, 3, new_powertype);
 
    if (GetTypeId() == TYPEID_PLAYER)
    {
        if (ToPlayer()->GetGroup())
            ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_POWER_TYPE);
    }
    else if (Pet* pet = ToCreature()->ToPet())
    {
        if (pet->isControlled())
        {
            Unit* owner = GetOwner();
            if (owner && (owner->GetTypeId() == TYPEID_PLAYER) && owner->ToPlayer()->GetGroup())
                owner->ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_POWER_TYPE);
        }
    }
 
    float powerMultiplier = 1.0f;
    if (!IsPet())
        if (Creature* creature = ToCreature())
            powerMultiplier = creature->GetCreatureTemplate()->ModMana;
 
    switch (new_powertype)
    {
        default:
        case POWER_MANA:
            break;
        case POWER_RAGE:
            SetMaxPower(POWER_RAGE, uint32(std::ceil(GetCreatePowers(POWER_RAGE) * powerMultiplier)));
            SetPower(POWER_RAGE, 0);
            break;
        case POWER_FOCUS:
            SetMaxPower(POWER_FOCUS, uint32(std::ceil(GetCreatePowers(POWER_FOCUS) * powerMultiplier)));
            SetPower(POWER_FOCUS, uint32(std::ceil(GetCreatePowers(POWER_FOCUS) * powerMultiplier)));
            break;
        case POWER_ENERGY:
            SetMaxPower(POWER_ENERGY, uint32(std::ceil(GetCreatePowers(POWER_ENERGY) * powerMultiplier)));
            break;
        case POWER_HAPPINESS:
            SetMaxPower(POWER_HAPPINESS, uint32(std::ceil(GetCreatePowers(POWER_HAPPINESS) * powerMultiplier)));
            SetPower(POWER_HAPPINESS, uint32(std::ceil(GetCreatePowers(POWER_HAPPINESS) * powerMultiplier)));
            break;
    }
 
    if (Player const* player = ToPlayer())
        if (player->NeedSendSpectatorData())
        {
            ArenaSpectator::SendCommand_UInt32Value(FindMap(), GetGUID(), "PWT", new_powertype);
            ArenaSpectator::SendCommand_UInt32Value(FindMap(), GetGUID(), "MPW", new_powertype == POWER_RAGE || new_powertype == POWER_RUNIC_POWER ? GetMaxPower(new_powertype) / 10 : GetMaxPower(new_powertype));
            ArenaSpectator::SendCommand_UInt32Value(FindMap(), GetGUID(), "CPW", new_powertype == POWER_RAGE || new_powertype == POWER_RUNIC_POWER ? GetPower(new_powertype) / 10 : GetPower(new_powertype));
        }
}

◆ SetPvP()

void Unit::SetPvP ( bool state )

inline

Definition at line 1517 of file Unit.h.

    {
        if (state)
            SetByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP);
        else
            RemoveByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP);
    }

◆ setRace()

void Unit::setRace ( uint8 race )

Definition at line 21035 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_PLAYER)
        m_race = race;
}

◆ SetRedirectThreat()

void Unit::SetRedirectThreat	(	ObjectGuid	guid,
		uint32	pct
	)

inline

Definition at line 2339 of file Unit.h.

2339{ _redirectThreatInfo.Set(guid, pct); }

RedirectThreatInfo::Set

void Set(ObjectGuid guid, uint32 pct)

Definition: Unit.h:956

◆ SetResistance()

void Unit::SetResistance	(	SpellSchools	school,
		int32	val
	)

inline

Definition at line 1435 of file Unit.h.

1435{ SetStatInt32Value(static_cast<uint16>(UNIT_FIELD_RESISTANCES) + school, val); }

◆ SetResistanceBuffMods()

void Unit::SetResistanceBuffMods	(	SpellSchools	school,
		bool	positive,
		float	val
	)

inline

Definition at line 2023 of file Unit.h.

2023{ SetFloatValue(positive ? static_cast<uint16>(UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE) + school : static_cast<uint16>(UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE) + + school, val); }

◆ SetRooted()

void Unit::SetRooted	(	bool	apply,
		bool	isStun = `false`
	)

protected

Definition at line 18222 of file Unit.cpp.

{
    if (apply)
    {
        if (m_rootTimes > 0) // blizzard internal check?
            m_rootTimes++;
 
        // MOVEMENTFLAG_ROOT cannot be used in conjunction with MOVEMENTFLAG_MASK_MOVING (tested 3.3.5a)
        // this will freeze clients. That's why we remove MOVEMENTFLAG_MASK_MOVING before
        // setting MOVEMENTFLAG_ROOT
        RemoveUnitMovementFlag(MOVEMENTFLAG_MASK_MOVING);
 
        if (IsFalling())
        {
            AddUnitMovementFlag(MOVEMENTFLAG_PENDING_ROOT);
        }
        else
        {
            AddUnitMovementFlag(MOVEMENTFLAG_ROOT);
        }
 
         // Creature specific
        if (GetTypeId() != TYPEID_PLAYER)
        {
            if (isStun && movespline->Finalized())
            {
                StopMovingOnCurrentPos();
            }
            else
            {
                StopMoving();
            }
        }
 
        if (m_movedByPlayer)
        {
            WorldPacket data(SMSG_FORCE_MOVE_ROOT, GetPackGUID().size() + 4);
            data << GetPackGUID();
            data << m_rootTimes;
            m_movedByPlayer->ToPlayer()->SendDirectMessage(&data);
        }
        else
        {
            WorldPacket data(SMSG_SPLINE_MOVE_ROOT, GetPackGUID().size());
            data << GetPackGUID();
            SendMessageToSet(&data, true);
        }
    }
    else
    {
        RemoveUnitMovementFlag(MOVEMENTFLAG_ROOT | MOVEMENTFLAG_PENDING_ROOT);
 
        if (!HasUnitState(UNIT_STATE_STUNNED))      // prevent moving if it also has stun effect
        {
            if (m_movedByPlayer)
            {
                WorldPacket data(SMSG_FORCE_MOVE_UNROOT, GetPackGUID().size() + 4);
                data << GetPackGUID();
                data << m_rootTimes;
                m_movedByPlayer->ToPlayer()->SendDirectMessage(&data);
            }
            else
            {
                WorldPacket data(SMSG_SPLINE_MOVE_UNROOT, GetPackGUID().size());
                data << GetPackGUID();
                SendMessageToSet(&data, true);
            }
        }
    }
}

◆ SetShapeshiftForm()

void Unit::SetShapeshiftForm ( ShapeshiftForm form )

inline

Definition at line 2069 of file Unit.h.

    {
        SetByteValue(UNIT_FIELD_BYTES_2, 3, form);
    }

◆ SetSheath()

virtual void Unit::SetSheath ( SheathState sheathed )

inlinevirtual

Reimplemented in Player.

Definition at line 1490 of file Unit.h.

1490{ SetByteValue(UNIT_FIELD_BYTES_2, 0, sheathed); }

◆ SetSpeed()

void Unit::SetSpeed	(	UnitMoveType	mtype,
		float	rate,
		bool	forced = `false`
	)

Definition at line 14301 of file Unit.cpp.

{
    if (rate < 0)
        rate = 0.0f;
 
    // Update speed only on change
    if (m_speed_rate[mtype] == rate)
        return;
 
    m_speed_rate[mtype] = rate;
 
    propagateSpeedChange();
 
    WorldPacket data;
    if (!forced)
    {
        switch (mtype)
        {
            case MOVE_WALK:
                data.Initialize(MSG_MOVE_SET_WALK_SPEED, 8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
                break;
            case MOVE_RUN:
                data.Initialize(MSG_MOVE_SET_RUN_SPEED, 8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
                break;
            case MOVE_RUN_BACK:
                data.Initialize(MSG_MOVE_SET_RUN_BACK_SPEED, 8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
                break;
            case MOVE_SWIM:
                data.Initialize(MSG_MOVE_SET_SWIM_SPEED, 8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
                break;
            case MOVE_SWIM_BACK:
                data.Initialize(MSG_MOVE_SET_SWIM_BACK_SPEED, 8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
                break;
            case MOVE_TURN_RATE:
                data.Initialize(MSG_MOVE_SET_TURN_RATE, 8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
                break;
            case MOVE_FLIGHT:
                data.Initialize(MSG_MOVE_SET_FLIGHT_SPEED, 8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
                break;
            case MOVE_FLIGHT_BACK:
                data.Initialize(MSG_MOVE_SET_FLIGHT_BACK_SPEED, 8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
                break;
            case MOVE_PITCH_RATE:
                data.Initialize(MSG_MOVE_SET_PITCH_RATE, 8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
                break;
            default:
                LOG_ERROR("entities.unit", "Unit::SetSpeed: Unsupported move type ({}), data not sent to client.", mtype);
                return;
        }
 
        data << GetPackGUID();
        BuildMovementPacket(&data);
        data << float(GetSpeed(mtype));
        SendMessageToSet(&data, true);
    }
    else
    {
        if (GetTypeId() == TYPEID_PLAYER)
        {
            // register forced speed changes for WorldSession::HandleForceSpeedChangeAck
            // and do it only for real sent packets and use run for run/mounted as client expected
            ++ToPlayer()->m_forced_speed_changes[mtype];
 
            // Xinef: update speed of pet also
            if (!IsInCombat())
            {
                Unit* pet = ToPlayer()->GetPet();
                if (!pet)
                    pet = GetCharm();
 
                // xinef: do not affect vehicles and possesed pets
                if (pet && (pet->HasUnitFlag(UNIT_FLAG_POSSESSED) || pet->IsVehicle()))
                    pet = nullptr;
 
                if (pet && pet->GetTypeId() == TYPEID_UNIT && !pet->IsInCombat() && pet->GetMotionMaster()->GetCurrentMovementGeneratorType() == FOLLOW_MOTION_TYPE)
                    pet->UpdateSpeed(mtype, forced);
                if (Unit* critter = ObjectAccessor::GetUnit(*this, GetCritterGUID()))
                    critter->UpdateSpeed(mtype, forced);
            }
            ToPlayer()->SetCanTeleport(true);
        }
 
        switch (mtype)
        {
            case MOVE_WALK:
                data.Initialize(SMSG_FORCE_WALK_SPEED_CHANGE, 16);
                break;
            case MOVE_RUN:
                data.Initialize(SMSG_FORCE_RUN_SPEED_CHANGE, 17);
                break;
            case MOVE_RUN_BACK:
                data.Initialize(SMSG_FORCE_RUN_BACK_SPEED_CHANGE, 16);
                break;
            case MOVE_SWIM:
                data.Initialize(SMSG_FORCE_SWIM_SPEED_CHANGE, 16);
                break;
            case MOVE_SWIM_BACK:
                data.Initialize(SMSG_FORCE_SWIM_BACK_SPEED_CHANGE, 16);
                break;
            case MOVE_TURN_RATE:
                data.Initialize(SMSG_FORCE_TURN_RATE_CHANGE, 16);
                break;
            case MOVE_FLIGHT:
                data.Initialize(SMSG_FORCE_FLIGHT_SPEED_CHANGE, 16);
                break;
            case MOVE_FLIGHT_BACK:
                data.Initialize(SMSG_FORCE_FLIGHT_BACK_SPEED_CHANGE, 16);
                break;
            case MOVE_PITCH_RATE:
                data.Initialize(SMSG_FORCE_PITCH_RATE_CHANGE, 16);
                break;
            default:
                LOG_ERROR("entities.unit", "Unit::SetSpeed: Unsupported move type ({}), data not sent to client.", mtype);
                return;
        }
        data << GetPackGUID();
        data << (uint32)0;                                  // moveEvent, NUM_PMOVE_EVTS = 0x39
        if (mtype == MOVE_RUN)
            data << uint8(0);                               // new 2.1.0
        data << float(GetSpeed(mtype));
        SendMessageToSet(&data, true);
    }
}

◆ SetSpeedRate()

void Unit::SetSpeedRate	(	UnitMoveType	mtype,
		float	rate
	)

inline

Definition at line 2245 of file Unit.h.

2245{ m_speed_rate[mtype] = rate; }

◆ SetStandFlags()

void Unit::SetStandFlags ( uint8 flags )

inline

Definition at line 1537 of file Unit.h.

1537{ SetByteFlag(UNIT_FIELD_BYTES_1, UNIT_BYTES_1_OFFSET_VIS_FLAG, flags); }

◆ SetStandState()

void Unit::SetStandState ( uint8 state )

Definition at line 16812 of file Unit.cpp.

{
    SetByteValue(UNIT_FIELD_BYTES_1, UNIT_BYTES_1_OFFSET_STAND_STATE, state);
 
    if (IsStandState())
        RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_NOT_SEATED);
 
    if (GetTypeId() == TYPEID_PLAYER)
    {
        WorldPacket data(SMSG_STANDSTATE_UPDATE, 1);
        data << (uint8)state;
        ToPlayer()->GetSession()->SendPacket(&data);
    }
}

◆ SetStat()

void Unit::SetStat	(	Stats	stat,
		int32	val
	)

inline

Definition at line 1429 of file Unit.h.

1429{ SetStatInt32Value(static_cast<uint16>(UNIT_FIELD_STAT0) + stat, val); }

◆ SetStunned()

void Unit::SetStunned ( bool apply )

protected

Definition at line 18179 of file Unit.cpp.

{
    if (apply)
    {
        SetTarget();
        SetUnitFlag(UNIT_FLAG_STUNNED);
 
        if (GetTypeId() == TYPEID_PLAYER)
        {
            SetStandState(UNIT_STAND_STATE_STAND);
        }
 
        SetRooted(true, true);
 
        CastStop();
    }
    else
    {
        if (IsAlive() && GetVictim())
            SetTarget(GetVictim()->GetGUID());
 
        if (GetTypeId() == TYPEID_UNIT)
        {
            // don't remove UNIT_FLAG_STUNNED for pet when owner is mounted (disabled pet's interface)
            Unit* owner = GetOwner();
            if (!owner || owner->GetTypeId() != TYPEID_PLAYER || !owner->ToPlayer()->IsMounted())
                RemoveUnitFlag(UNIT_FLAG_STUNNED);
 
            // Xinef: same for charmed npcs
            owner = GetCharmer();
            if (!owner || owner->GetTypeId() != TYPEID_PLAYER || !owner->ToPlayer()->IsMounted())
                RemoveUnitFlag(UNIT_FLAG_STUNNED);
        }
        else
            RemoveUnitFlag(UNIT_FLAG_STUNNED);
 
        if (!HasUnitState(UNIT_STATE_ROOT))         // prevent moving if it also has root effect
        {
            SetRooted(false, true);
        }
    }
}

◆ SetSwim()

bool Unit::SetSwim ( bool enable )

virtual

Reimplemented in Creature.

Definition at line 20674 of file Unit.cpp.

{
    if (enable == HasUnitMovementFlag(MOVEMENTFLAG_SWIMMING))
        return false;
 
    if (enable)
    {
        AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
        SetUnitFlag(UNIT_FLAG_SWIMMING);
    }
    else
    {
        RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
        RemoveUnitFlag(UNIT_FLAG_SWIMMING);
    }
 
    return true;
}

◆ SetTarget()

virtual void Unit::SetTarget ( ObjectGuid = ObjectGuid::Empty )

pure virtual

Implemented in Creature, and Player.

◆ setTransForm()

void Unit::setTransForm ( uint32 spellid )

inline

Definition at line 2168 of file Unit.h.

2168{ m_transform = spellid;}

◆ SetUnitFlag()

void Unit::SetUnitFlag ( UnitFlags flags )

inline

Definition at line 1479 of file Unit.h.

1479{ SetFlag(UNIT_FIELD_FLAGS, flags); }

◆ SetUnitFlag2()

void Unit::SetUnitFlag2 ( UnitFlags2 flags )

inline

Definition at line 1485 of file Unit.h.

1485{ SetFlag(UNIT_FIELD_FLAGS_2, flags); }

◆ SetUnitMovementFlags()

void Unit::SetUnitMovementFlags ( uint32 f )

inline

Definition at line 2271 of file Unit.h.

2271{ m_movementInfo.flags = f; }

◆ SetVisible()

void Unit::SetVisible ( bool x )

Definition at line 14117 of file Unit.cpp.

{
    if (!x)
        m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GM, SEC_GAMEMASTER);
    else
        m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GM, SEC_PLAYER);
 
    UpdateObjectVisibility();
}

◆ SetVisibleAura()

void Unit::SetVisibleAura	(	uint8	slot,
		AuraApplication *	aur
	)

inline

Definition at line 2156 of file Unit.h.

2156{ m_visibleAuras[slot] = aur; UpdateAuraForGroup(slot);}

◆ SetWalk()

bool Unit::SetWalk ( bool enable )

virtual

Reimplemented in Creature.

Definition at line 20642 of file Unit.cpp.

{
    if (enable == IsWalking())
        return false;
 
    if (enable)
        AddUnitMovementFlag(MOVEMENTFLAG_WALKING);
    else
        RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
 
    propagateSpeedChange();
    return true;
}

◆ SetWaterWalking()

bool Unit::SetWaterWalking	(	bool	enable,
		bool	packetOnly = `false`
	)

virtual

Reimplemented in Player, and Creature.

Definition at line 20711 of file Unit.cpp.

{
    if (enable == HasUnitMovementFlag(MOVEMENTFLAG_WATERWALKING))
        return false;
 
    if (enable)
        AddUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
    else
        RemoveUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
 
    return true;
}

◆ SpellBaseDamageBonusDone()

int32 Unit::SpellBaseDamageBonusDone ( SpellSchoolMask schoolMask )

Definition at line 11848 of file Unit.cpp.

{
    int32 DoneAdvertisedBenefit = 0;
 
    AuraEffectList const& mDamageDone = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE);
    for (AuraEffectList::const_iterator i = mDamageDone.begin(); i != mDamageDone.end(); ++i)
        if (((*i)->GetMiscValue() & schoolMask) != 0 &&
                (*i)->GetSpellInfo()->EquippedItemClass == -1 &&
                // -1 == any item class (not wand then)
                (*i)->GetSpellInfo()->EquippedItemInventoryTypeMask == 0)
            // 0 == any inventory type (not wand then)
            DoneAdvertisedBenefit += (*i)->GetAmount();
 
    if (GetTypeId() == TYPEID_PLAYER)
    {
        // Base value
        DoneAdvertisedBenefit += ToPlayer()->GetBaseSpellPowerBonus();
 
        // Damage bonus from stats
        AuraEffectList const& mDamageDoneOfStatPercent = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_DAMAGE_OF_STAT_PERCENT);
        for (AuraEffectList::const_iterator i = mDamageDoneOfStatPercent.begin(); i != mDamageDoneOfStatPercent.end(); ++i)
        {
            if ((*i)->GetMiscValue() & schoolMask)
            {
                // stat used stored in miscValueB for this aura
                Stats usedStat = Stats((*i)->GetMiscValueB());
                DoneAdvertisedBenefit += int32(CalculatePct(GetStat(usedStat), (*i)->GetAmount()));
            }
        }
        // ... and attack power
        AuraEffectList const& mDamageDonebyAP = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_DAMAGE_OF_ATTACK_POWER);
        for (AuraEffectList::const_iterator i = mDamageDonebyAP.begin(); i != mDamageDonebyAP.end(); ++i)
            if ((*i)->GetMiscValue() & schoolMask)
                DoneAdvertisedBenefit += int32(CalculatePct(GetTotalAttackPowerValue(BASE_ATTACK), (*i)->GetAmount()));
    }
    return DoneAdvertisedBenefit;
}

◆ SpellBaseDamageBonusTaken()

int32 Unit::SpellBaseDamageBonusTaken	(	SpellSchoolMask	schoolMask,
		bool	isDoT = `false`
	)

Definition at line 11886 of file Unit.cpp.

{
    int32 TakenAdvertisedBenefit = 0;
 
    AuraEffectList const& mDamageTaken = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_TAKEN);
    for (AuraEffectList::const_iterator i = mDamageTaken.begin(); i != mDamageTaken.end(); ++i)
        if (((*i)->GetMiscValue() & schoolMask) != 0)
        {
            // Xinef: if we have DoT damage type and aura has charges, check if it affects DoTs
            // Xinef: required for hemorrhage & rupture / garrote
            if (isDoT && (*i)->GetBase()->IsUsingCharges() && !((*i)->GetSpellInfo()->ProcFlags & PROC_FLAG_TAKEN_PERIODIC))
                continue;
 
            TakenAdvertisedBenefit += (*i)->GetAmount();
        }
 
    return TakenAdvertisedBenefit;
}

◆ SpellBaseHealingBonusDone()

int32 Unit::SpellBaseHealingBonusDone ( SpellSchoolMask schoolMask )

Definition at line 12606 of file Unit.cpp.

{
    int32 AdvertisedBenefit = 0;
 
    AuraEffectList const& mHealingDone = GetAuraEffectsByType(SPELL_AURA_MOD_HEALING_DONE);
    for (AuraEffectList::const_iterator i = mHealingDone.begin(); i != mHealingDone.end(); ++i)
        if (!(*i)->GetMiscValue() || ((*i)->GetMiscValue() & schoolMask) != 0)
            AdvertisedBenefit += (*i)->GetAmount();
 
    // Healing bonus of spirit, intellect and strength
    if (GetTypeId() == TYPEID_PLAYER)
    {
        // Base value
        AdvertisedBenefit += ToPlayer()->GetBaseSpellPowerBonus();
 
        // Healing bonus from stats
        AuraEffectList const& mHealingDoneOfStatPercent = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT);
        for (AuraEffectList::const_iterator i = mHealingDoneOfStatPercent.begin(); i != mHealingDoneOfStatPercent.end(); ++i)
        {
            // stat used dependent from misc value (stat index)
            Stats usedStat = Stats((*i)->GetSpellInfo()->Effects[(*i)->GetEffIndex()].MiscValue);
            AdvertisedBenefit += int32(CalculatePct(GetStat(usedStat), (*i)->GetAmount()));
        }
 
        // ... and attack power
        AuraEffectList const& mHealingDonebyAP = GetAuraEffectsByType(SPELL_AURA_MOD_SPELL_HEALING_OF_ATTACK_POWER);
        for (AuraEffectList::const_iterator i = mHealingDonebyAP.begin(); i != mHealingDonebyAP.end(); ++i)
            if ((*i)->GetMiscValue() & schoolMask)
                AdvertisedBenefit += int32(CalculatePct(GetTotalAttackPowerValue(BASE_ATTACK), (*i)->GetAmount()));
    }
    return AdvertisedBenefit;
}

◆ SpellBaseHealingBonusTaken()

int32 Unit::SpellBaseHealingBonusTaken ( SpellSchoolMask schoolMask )

Definition at line 12639 of file Unit.cpp.

{
    int32 AdvertisedBenefit = 0;
 
    AuraEffectList const& mDamageTaken = GetAuraEffectsByType(SPELL_AURA_MOD_HEALING);
    for (AuraEffectList::const_iterator i = mDamageTaken.begin(); i != mDamageTaken.end(); ++i)
        if (((*i)->GetMiscValue() & schoolMask) != 0)
            AdvertisedBenefit += (*i)->GetAmount();
 
    return AdvertisedBenefit;
}

◆ SpellCriticalDamageBonus()

uint32 Unit::SpellCriticalDamageBonus	(	Unit const *	caster,
		SpellInfo const *	spellProto,
		uint32	damage,
		Unit const *	victim
	)

static

Definition at line 12192 of file Unit.cpp.

{
    // Calculate critical bonus
    int32 crit_bonus = damage;
    float crit_mod = 0.0f;
 
    switch (spellProto->DmgClass)
    {
        case SPELL_DAMAGE_CLASS_MELEE:                      // for melee based spells is 100%
        case SPELL_DAMAGE_CLASS_RANGED:
            // TODO: write here full calculation for melee/ranged spells
            crit_bonus += damage;
            break;
        default:
            crit_bonus += damage / 2;                       // for spells is 50%
            break;
    }
 
    if (caster)
    {
        crit_mod += caster->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS, spellProto->GetSchoolMask());
 
        if (victim)
            crit_mod += caster->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, victim->GetCreatureTypeMask());
 
        if (crit_bonus != 0 && crit_mod != 0.0f)
            AddPct(crit_bonus, crit_mod);
 
        crit_bonus -= damage;
 
        // adds additional damage to critBonus (from talents)
        if (Player* modOwner = caster->GetSpellModOwner())
            modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
 
        crit_bonus += damage;
    }
 
    return crit_bonus;
}

◆ SpellCriticalHealingBonus()

uint32 Unit::SpellCriticalHealingBonus	(	Unit const *	caster,
		SpellInfo const *	spellProto,
		uint32	damage,
		Unit const *	victim
	)

static

Definition at line 12232 of file Unit.cpp.

{
    // Calculate critical bonus
    int32 crit_bonus;
    switch (spellProto->DmgClass)
    {
        case SPELL_DAMAGE_CLASS_MELEE:                      // for melee based spells is 100%
        case SPELL_DAMAGE_CLASS_RANGED:
            // TODO: write here full calculation for melee/ranged spells
            crit_bonus = damage;
            break;
        default:
            crit_bonus = damage / 2;                        // for spells is 50%
            break;
    }
 
    if (caster)
    {
        if (victim)
        {
            uint32 creatureTypeMask = victim->GetCreatureTypeMask();
            crit_bonus = int32(crit_bonus * caster->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, creatureTypeMask));
        }
 
        // adds additional damage to critBonus (from talents)
        // xinef: used for death knight death coil
        if (Player* modOwner = caster->GetSpellModOwner())
            modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
    }
 
    if (crit_bonus > 0)
        damage += crit_bonus;
 
    if (caster)
        damage = int32(float(damage) * caster->GetTotalAuraMultiplier(SPELL_AURA_MOD_CRITICAL_HEALING_AMOUNT));
 
    return damage;
}

◆ SpellDamageBonusDone()

uint32 Unit::SpellDamageBonusDone	(	Unit *	victim,
		SpellInfo const *	spellProto,
		uint32	pdamage,
		DamageEffectType	damagetype,
		uint8	effIndex,
		float	TotalMod = `0.0f`,
		uint32	stack = `1`
	)

Definition at line 11559 of file Unit.cpp.

{
    if (!spellProto || !victim || damagetype == DIRECT_DAMAGE)
        return pdamage;
 
    // Some spells don't benefit from done mods
    if (spellProto->HasAttribute(SPELL_ATTR3_IGNORE_CASTER_MODIFIERS))
        return pdamage;
 
    // For totems get damage bonus from owner
    if (GetTypeId() == TYPEID_UNIT)
    {
        if (IsTotem())
        {
            if (Unit* owner = GetOwner())
                return owner->SpellDamageBonusDone(victim, spellProto, pdamage, damagetype, effIndex, TotalMod, stack);
        }
        // Dancing Rune Weapon...
        else if (GetEntry() == 27893)
        {
            if (Unit* owner = GetOwner())
                return owner->SpellDamageBonusDone(victim, spellProto, pdamage, damagetype, TotalMod, stack) / 2;
        }
    }
 
    // Done total percent damage auras
    float ApCoeffMod = 1.0f;
    int32 DoneTotal = 0;
    float DoneTotalMod = TotalMod ? TotalMod : SpellPctDamageModsDone(victim, spellProto, damagetype);
 
    // Config : RATE_CREATURE_X_SPELLDAMAGE & Do Not Modify Pet/Guardian/Mind Controled Damage
    if (GetTypeId() == TYPEID_UNIT && (!ToCreature()->IsPet() || !ToCreature()->IsGuardian() || !ToCreature()->IsControlledByPlayer()))
        DoneTotalMod *= ToCreature()->GetSpellDamageMod(ToCreature()->GetCreatureTemplate()->rank);
 
    // Some spells don't benefit from pct done mods
    if (!spellProto->HasAttribute(SPELL_ATTR6_IGNORE_CASTER_DAMAGE_MODIFIERS))
    {
        uint32 creatureTypeMask = victim->GetCreatureTypeMask();
        // Add flat bonus from spell damage versus
        DoneTotal += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_FLAT_SPELL_DAMAGE_VERSUS, creatureTypeMask);
    }
 
    // done scripted mod (take it from owner)
    Unit* owner = GetOwner() ? GetOwner() : this;
    AuraEffectList const& mOverrideClassScript = owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
    for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
    {
        if (!(*i)->IsAffectedOnSpell(spellProto))
            continue;
 
        switch ((*i)->GetMiscValue())
        {
            case 4418: // Increased Shock Damage
            case 4554: // Increased Lightning Damage
            case 4555: // Improved Moonfire
            case 5142: // Increased Lightning Damage
            case 5147: // Improved Consecration / Libram of Resurgence
            case 5148: // Idol of the Shooting Star
            case 6008: // Increased Lightning Damage
            case 8627: // Totem of Hex
                {
                    DoneTotal += (*i)->GetAmount();
                    break;
                }
        }
    }
 
    // Custom scripted damage
    if (spellProto->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT)
    {
        // Sigil of the Vengeful Heart
        if (spellProto->SpellFamilyFlags[0] & 0x2000)
            if (AuraEffect* aurEff = GetAuraEffect(64962, EFFECT_1))
                AddPct(DoneTotal, aurEff->GetAmount());
 
        // Impurity
        if (AuraEffect* aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 1986, 0))
            AddPct(ApCoeffMod, aurEff->GetAmount());
 
        // Blood Boil - bonus for diseased targets
        if (spellProto->SpellFamilyFlags[0] & 0x00040000)
            if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DEATHKNIGHT, 0, 0, 0x00000002, GetGUID()))
            {
                DoneTotal += 95;
                ApCoeffMod = 1.5835f;
            }
    }
 
    // Done fixed damage bonus auras
    int32 DoneAdvertisedBenefit  = SpellBaseDamageBonusDone(spellProto->GetSchoolMask());
 
    // Check for table values
    float coeff = spellProto->Effects[effIndex].BonusMultiplier;
    SpellBonusEntry const* bonus = sSpellMgr->GetSpellBonusData(spellProto->Id);
    if (bonus)
    {
        if (damagetype == DOT)
        {
            coeff = bonus->dot_damage;
            if (bonus->ap_dot_bonus > 0)
            {
                WeaponAttackType attType = (spellProto->IsRangedWeaponSpell() && spellProto->DmgClass != SPELL_DAMAGE_CLASS_MELEE) ? RANGED_ATTACK : BASE_ATTACK;
                float APbonus = float(victim->GetTotalAuraModifier(attType == BASE_ATTACK ? SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS : SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS));
                APbonus += GetTotalAttackPowerValue(attType);
                DoneTotal += int32(bonus->ap_dot_bonus * stack * ApCoeffMod * APbonus);
            }
        }
        else
        {
            coeff = bonus->direct_damage;
            if (bonus->ap_bonus > 0)
            {
                WeaponAttackType attType = (spellProto->IsRangedWeaponSpell() && spellProto->DmgClass != SPELL_DAMAGE_CLASS_MELEE) ? RANGED_ATTACK : BASE_ATTACK;
                float APbonus = float(victim->GetTotalAuraModifier(attType == BASE_ATTACK ? SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS : SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS));
                APbonus += GetTotalAttackPowerValue(attType);
                DoneTotal += int32(bonus->ap_bonus * stack * ApCoeffMod * APbonus);
            }
        }
    }
 
    // Default calculation
    if (coeff && DoneAdvertisedBenefit)
    {
        float factorMod = CalculateLevelPenalty(spellProto) * stack;
 
        if (Player* modOwner = GetSpellModOwner())
        {
            coeff *= 100.0f;
            modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_BONUS_MULTIPLIER, coeff);
            coeff /= 100.0f;
        }
 
        DoneTotal += int32(DoneAdvertisedBenefit * coeff * factorMod);
    }
 
    float tmpDamage = (float(pdamage) + DoneTotal) * DoneTotalMod;
    // apply spellmod to Done damage (flat and pct)
    if (Player* modOwner = GetSpellModOwner())
        modOwner->ApplySpellMod(spellProto->Id, damagetype == DOT ? SPELLMOD_DOT : SPELLMOD_DAMAGE, tmpDamage);
 
    return uint32(std::max(tmpDamage, 0.0f));
}

◆ SpellDamageBonusTaken()

uint32 Unit::SpellDamageBonusTaken	(	Unit *	caster,
		SpellInfo const *	spellProto,
		uint32	pdamage,
		DamageEffectType	damagetype,
		uint32	stack = `1`
	)

Definition at line 11702 of file Unit.cpp.

{
    if (!spellProto || damagetype == DIRECT_DAMAGE)
        return pdamage;
 
    int32 TakenTotal = 0;
    float TakenTotalMod = 1.0f;
 
    // from positive and negative SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN
    // multiplicative bonus, for example Dispersion + Shadowform (0.10*0.85=0.085)
    AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
    for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        if (((*i)->GetMiscValue() & spellProto->GetSchoolMask()))
            if (spellProto->ValidateAttribute6SpellDamageMods(caster, *i, damagetype == DOT))
                AddPct(TakenTotalMod, (*i)->GetAmount());
 
    TakenTotalMod = processDummyAuras(TakenTotalMod);
 
    // From caster spells
    if (caster)
    {
        AuraEffectList const& mOwnerTaken = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_FROM_CASTER);
        for (AuraEffectList::const_iterator i = mOwnerTaken.begin(); i != mOwnerTaken.end(); ++i)
            if ((*i)->GetCasterGUID() == caster->GetGUID() && (*i)->IsAffectedOnSpell(spellProto))
                if (spellProto->ValidateAttribute6SpellDamageMods(caster, *i, damagetype == DOT))
                    AddPct(TakenTotalMod, (*i)->GetAmount());
    }
 
    if (uint32 mechanicMask = spellProto->GetAllEffectsMechanicMask())
    {
        int32 modifierMax = 0;
        int32 modifierMin = 0;
        AuraEffectList const& auraEffectList = GetAuraEffectsByType(SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
        for (AuraEffectList::const_iterator i = auraEffectList.begin(); i != auraEffectList.end(); ++i)
        {
            if (!spellProto->ValidateAttribute6SpellDamageMods(caster, *i, damagetype == DOT))
                continue;
 
            // Only death knight spell with this aura
            if ((*i)->GetSpellInfo()->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT)
                if (!caster || caster->GetGUID() != (*i)->GetCasterGUID())
                    continue;
 
            if (mechanicMask & uint32(1 << (*i)->GetMiscValue()))
            {
                if ((*i)->GetAmount() > 0)
                {
                    if ((*i)->GetAmount() > modifierMax)
                        modifierMax = (*i)->GetAmount();
                }
                else if ((*i)->GetAmount() < modifierMin)
                    modifierMin = (*i)->GetAmount();
            }
        }
 
        AddPct(TakenTotalMod, modifierMax);
        AddPct(TakenTotalMod, modifierMin);
    }
 
    int32 TakenAdvertisedBenefit = SpellBaseDamageBonusTaken(spellProto->GetSchoolMask(), damagetype == DOT);
 
    // Check for table values
    float coeff = 0;
    SpellBonusEntry const* bonus = sSpellMgr->GetSpellBonusData(spellProto->Id);
    if (bonus)
        coeff = (damagetype == DOT) ? bonus->dot_damage : bonus->direct_damage;
 
    // Default calculation
    if (TakenAdvertisedBenefit)
    {
        if (coeff <= 0.0f)
        {
            if (caster)
                coeff = caster->CalculateDefaultCoefficient(spellProto, damagetype) * int32(stack);
            else
                coeff = CalculateDefaultCoefficient(spellProto, damagetype) * int32(stack);
        }
 
        float factorMod = CalculateLevelPenalty(spellProto) * stack;
        TakenTotal += int32(TakenAdvertisedBenefit * coeff * factorMod);
    }
 
    // No positive taken bonus, custom attr
    if (spellProto->HasAttribute(SPELL_ATTR0_CU_NO_POSITIVE_TAKEN_BONUS) && TakenTotalMod > 1.0f)
    {
        TakenTotal = 0;
        TakenTotalMod = 1.0f;
    }
 
    // xinef: sanctified wrath talent
    if (caster && TakenTotalMod < 1.0f && caster->HasAuraType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST))
    {
        float ignoreModifier = 1.0f - TakenTotalMod;
        bool addModifier = false;
        AuraEffectList const& ResIgnoreAuras = caster->GetAuraEffectsByType(SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
        for (AuraEffectList::const_iterator j = ResIgnoreAuras.begin(); j != ResIgnoreAuras.end(); ++j)
            if ((*j)->GetMiscValue() & spellProto->SchoolMask)
            {
                ApplyPct(ignoreModifier, (*j)->GetAmount());
                addModifier = true;
            }
 
        if (addModifier)
            TakenTotalMod += ignoreModifier;
    }
 
    float tmpDamage = (float(pdamage) + TakenTotal) * TakenTotalMod;
 
    return uint32(std::max(tmpDamage, 0.0f));
}

◆ SpellDoneCritChance()

float Unit::SpellDoneCritChance	(	Unit const *	,
		SpellInfo const *	spellProto,
		SpellSchoolMask	schoolMask,
		WeaponAttackType	attackType,
		bool	skipEffectCheck
	)		const

Definition at line 11905 of file Unit.cpp.

{
    // Mobs can't crit with spells.
    if (GetTypeId() == TYPEID_UNIT && !GetSpellModOwner())
        return -100.0f;
 
    // not critting spell
    if (spellProto->HasAttribute(SPELL_ATTR2_CANT_CRIT))
        return 0.0f;
 
    // Xinef: check if spell is capable of critting, auras requires special aura to crit so they can be skipped
    if (!skipEffectCheck && !spellProto->IsCritCapable())
        return 0.0f;
 
    float crit_chance = 0.0f;
    switch (spellProto->DmgClass)
    {
        case SPELL_DAMAGE_CLASS_MAGIC:
            {
                if (schoolMask & SPELL_SCHOOL_MASK_NORMAL)
                    crit_chance = 0.0f;
                // For other schools
                else if (GetTypeId() == TYPEID_PLAYER)
                    crit_chance = GetFloatValue(static_cast<uint16>(PLAYER_SPELL_CRIT_PERCENTAGE1) + GetFirstSchoolInMask(schoolMask));
                else
                {
                    crit_chance = (float)m_baseSpellCritChance;
                    crit_chance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
                }
                break;
            }
        case SPELL_DAMAGE_CLASS_MELEE:
        case SPELL_DAMAGE_CLASS_RANGED:
            {
                if (GetTypeId() == TYPEID_PLAYER)
                {
                    switch (attackType)
                    {
                        case BASE_ATTACK:
                            crit_chance = GetFloatValue(PLAYER_CRIT_PERCENTAGE);
                            break;
                        case OFF_ATTACK:
                            crit_chance = GetFloatValue(PLAYER_OFFHAND_CRIT_PERCENTAGE);
                            break;
                        case RANGED_ATTACK:
                            crit_chance = GetFloatValue(PLAYER_RANGED_CRIT_PERCENTAGE);
                            break;
                        default:
                            break;
                    }
                }
                else
                {
                    crit_chance = 5.0f;
                    crit_chance += GetTotalAuraModifier(SPELL_AURA_MOD_WEAPON_CRIT_PERCENT);
                    crit_chance += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_PCT);
                }
                crit_chance += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
                break;
            }
        // values overridden in spellmgr for lifebloom and earth shield
        case SPELL_DAMAGE_CLASS_NONE:
        default:
            return 0.0f;
    }
 
    // percent done
    // only players use intelligence for critical chance computations
    if (Player* modOwner = GetSpellModOwner())
        modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CRITICAL_CHANCE, crit_chance);
 
    // xinef: can be negative!
    return crit_chance;
}

◆ SpellHealingBonusDone()

uint32 Unit::SpellHealingBonusDone	(	Unit *	victim,
		SpellInfo const *	spellProto,
		uint32	healamount,
		DamageEffectType	damagetype,
		uint8	effIndex,
		float	TotalMod = `0.0f`,
		uint32	stack = `1`
	)

Definition at line 12363 of file Unit.cpp.

{
    // For totems get healing bonus from owner (statue isn't totem in fact)
    if (GetTypeId() == TYPEID_UNIT && IsTotem())
        if (Unit* owner = GetOwner())
            return owner->SpellHealingBonusDone(victim, spellProto, healamount, damagetype, effIndex, TotalMod, stack);
 
    // No bonus healing for potion spells
    if (spellProto->SpellFamilyName == SPELLFAMILY_POTION)
        return healamount;
 
    float ApCoeffMod = 1.0f;
    float DoneTotalMod = TotalMod ? TotalMod : SpellPctHealingModsDone(victim, spellProto, damagetype);
    int32 DoneTotal = 0;
 
    // done scripted mod (take it from owner)
    Unit* owner = GetOwner() ? GetOwner() : this;
    AuraEffectList const& mOverrideClassScript = owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
    for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
    {
        if (!(*i)->IsAffectedOnSpell(spellProto))
            continue;
        switch ((*i)->GetMiscValue())
        {
            case 4415: // Increased Rejuvenation Healing
            case 4953:
                DoneTotal += (*i)->GetAmount() / 5; // 5 ticks of Rejuvenation
                break;
            case 3736: // Hateful Totem of the Third Wind / Increased Lesser Healing Wave / LK Arena (4/5/6) Totem of the Third Wind / Savage Totem of the Third Wind
                DoneTotal += (*i)->GetAmount();
                break;
        }
    }
 
    // Done fixed damage bonus auras
    int32 DoneAdvertisedBenefit = SpellBaseHealingBonusDone(spellProto->GetSchoolMask());
    float coeff = spellProto->Effects[effIndex].BonusMultiplier;
 
    switch (spellProto->SpellFamilyName)
    {
        case SPELLFAMILY_DEATHKNIGHT:
            // Impurity
            if (AuraEffect* aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 1986, 0))
                AddPct(ApCoeffMod, aurEff->GetAmount());
 
            break;
    }
 
    // Check for table values
    SpellBonusEntry const* bonus = sSpellMgr->GetSpellBonusData(spellProto->Id);
    if(bonus)
    {
        if (damagetype == DOT)
        {
            coeff = bonus->dot_damage;
            if (bonus->ap_dot_bonus > 0)
                DoneTotal += int32(bonus->ap_dot_bonus * ApCoeffMod * stack * GetTotalAttackPowerValue(
                                       (spellProto->IsRangedWeaponSpell() && spellProto->DmgClass != SPELL_DAMAGE_CLASS_MELEE) ? RANGED_ATTACK : BASE_ATTACK));
        }
        else
        {
            coeff = bonus->direct_damage;
            if (bonus->ap_bonus > 0)
                DoneTotal += int32(bonus->ap_bonus * ApCoeffMod * stack * GetTotalAttackPowerValue(
                                       (spellProto->IsRangedWeaponSpell() && spellProto->DmgClass != SPELL_DAMAGE_CLASS_MELEE) ? RANGED_ATTACK : BASE_ATTACK));
        }
    }
    else
    {
        // No bonus healing for SPELL_DAMAGE_CLASS_NONE class spells by default
        if (spellProto->DmgClass == SPELL_DAMAGE_CLASS_NONE)
            return healamount;
    }
 
    // Default calculation
    if (DoneAdvertisedBenefit)
    {
        float factorMod = CalculateLevelPenalty(spellProto) * stack;
        if (Player* modOwner = GetSpellModOwner())
        {
            coeff *= 100.0f;
            modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_BONUS_MULTIPLIER, coeff);
            coeff /= 100.0f;
        }
        DoneTotal += int32(DoneAdvertisedBenefit * coeff * factorMod);
    }
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        switch (spellProto->Effects[i].ApplyAuraName)
        {
            // Bonus healing does not apply to these spells
            case SPELL_AURA_PERIODIC_LEECH:
            case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
                DoneTotal = 0;
                break;
        }
        if (spellProto->Effects[i].Effect == SPELL_EFFECT_HEALTH_LEECH)
            DoneTotal = 0;
    }
 
    // use float as more appropriate for negative values and percent applying
    float heal = float(int32(healamount) + DoneTotal) * DoneTotalMod;
    // apply spellmod to Done amount
 
    if (Player* modOwner = GetSpellModOwner())
        modOwner->ApplySpellMod(spellProto->Id, damagetype == DOT ? SPELLMOD_DOT : SPELLMOD_DAMAGE, heal);
 
    return uint32(std::max(heal, 0.0f));
}

◆ SpellHealingBonusTaken()

uint32 Unit::SpellHealingBonusTaken	(	Unit *	caster,
		SpellInfo const *	spellProto,
		uint32	healamount,
		DamageEffectType	damagetype,
		uint32	stack = `1`
	)

Definition at line 12474 of file Unit.cpp.

{
    float TakenTotalMod = 1.0f;
    float minval = 0.0f;
 
    // Healing taken percent
    if (!sScriptMgr->OnSpellHealingBonusTakenNegativeModifiers(this, caster, spellProto, minval))
    {
        minval = float(GetMaxNegativeAuraModifier(SPELL_AURA_MOD_HEALING_PCT));
    }
 
    if (minval)
        AddPct(TakenTotalMod, minval);
 
    float maxval = float(GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HEALING_PCT));
    if (maxval)
        AddPct(TakenTotalMod, maxval);
 
    // Tenacity increase healing % taken
    if (AuraEffect const* Tenacity = GetAuraEffect(58549, 0))
        AddPct(TakenTotalMod, Tenacity->GetAmount());
 
    // Healing Done
    int32 TakenTotal = 0;
 
    // Taken fixed damage bonus auras
    int32 TakenAdvertisedBenefit = SpellBaseHealingBonusTaken(spellProto->GetSchoolMask());
 
    // Nourish cast, glyph of nourish
    if (spellProto->SpellFamilyName == SPELLFAMILY_DRUID && spellProto->SpellFamilyFlags[1] & 0x2000000 && caster)
    {
        bool any = false;
        bool hasglyph = caster->GetAuraEffectDummy(62971);
        AuraEffectList const& auras = GetAuraEffectsByType(SPELL_AURA_PERIODIC_HEAL);
        for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
        {
            if (((*i)->GetCasterGUID() == caster->GetGUID()))
            {
                SpellInfo const* spell = (*i)->GetSpellInfo();
                // Rejuvenation, Regrowth, Lifebloom, or Wild Growth
                if (!any && spell->SpellFamilyFlags.HasFlag(0x50, 0x4000010, 0))
                {
                    TakenTotalMod *= 1.2f;
                    any = true;
                }
 
                if (hasglyph)
                    TakenTotalMod += 0.06f;
            }
        }
    }
 
    if (damagetype == DOT)
    {
        // Healing over time taken percent
        float minval_hot = float(GetMaxNegativeAuraModifier(SPELL_AURA_MOD_HOT_PCT));
        if (minval_hot)
            AddPct(TakenTotalMod, minval_hot);
 
        float maxval_hot = float(GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HOT_PCT));
        if (maxval_hot)
            AddPct(TakenTotalMod, maxval_hot);
    }
 
    // Check for table values
    SpellBonusEntry const* bonus = sSpellMgr->GetSpellBonusData(spellProto->Id);
    float coeff = 0;
    float factorMod = 1.0f;
    if (bonus)
        coeff = (damagetype == DOT) ? bonus->dot_damage : bonus->direct_damage;
    else
    {
        // No bonus healing for SPELL_DAMAGE_CLASS_NONE class spells by default
        if (spellProto->DmgClass == SPELL_DAMAGE_CLASS_NONE)
        {
            healamount = uint32(std::max((float(healamount) * TakenTotalMod), 0.0f));
            return healamount;
        }
    }
 
    // Default calculation
    if (TakenAdvertisedBenefit)
    {
        float TakenCoeff = 0.0f;
        if (coeff <= 0)
            coeff = CalculateDefaultCoefficient(spellProto, damagetype) * int32(stack) * 1.88f;  // As wowwiki says: C = (Cast Time / 3.5) * 1.88 (for healing spells)
 
        factorMod *= CalculateLevelPenalty(spellProto) * int32(stack);
        if (Player* modOwner = GetSpellModOwner())
        {
            coeff *= 100.0f;
            modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_BONUS_MULTIPLIER, coeff);
            coeff /= 100.0f;
        }
 
        TakenTotal += int32(TakenAdvertisedBenefit * (coeff > 0 ? coeff : TakenCoeff) * factorMod);
    }
 
    if (caster)
    {
        AuraEffectList const& mHealingGet = GetAuraEffectsByType(SPELL_AURA_MOD_HEALING_RECEIVED);
        for (AuraEffectList::const_iterator i = mHealingGet.begin(); i != mHealingGet.end(); ++i)
            if (caster->GetGUID() == (*i)->GetCasterGUID() && (*i)->IsAffectedOnSpell(spellProto))
                AddPct(TakenTotalMod, (*i)->GetAmount());
    }
 
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        switch (spellProto->Effects[i].ApplyAuraName)
        {
            // Bonus healing does not apply to these spells
            case SPELL_AURA_PERIODIC_LEECH:
            case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
                TakenTotal = 0;
                break;
        }
        if (spellProto->Effects[i].Effect == SPELL_EFFECT_HEALTH_LEECH)
            TakenTotal = 0;
    }
 
    // No positive taken bonus, custom attr
    if ((spellProto->HasAttribute(SPELL_ATTR6_IGNORE_HEALTH_MODIFIERS) || spellProto->HasAttribute(SPELL_ATTR0_CU_NO_POSITIVE_TAKEN_BONUS)) && TakenTotalMod > 1.0f)
    {
        TakenTotal = 0;
        TakenTotalMod = 1.0f;
    }
 
    float heal = float(int32(healamount) + TakenTotal) * TakenTotalMod;
 
    return uint32(std::max(heal, 0.0f));
}

◆ SpellHitResult() [1/2]

SpellMissInfo Unit::SpellHitResult	(	Unit *	victim,
		Spell const *	spell,
		bool	canReflect = `false`
	)

Definition at line 3476 of file Unit.cpp.

{
    SpellInfo const* spellInfo = spell->GetSpellInfo();
 
    // Check for immune
    if (victim->IsImmunedToSpell(spellInfo, spell))
    {
        return SPELL_MISS_IMMUNE;
    }
 
    // All positive spells can`t miss
    // TODO: client not show miss log for this spells - so need find info for this in dbc and use it!
    if ((spellInfo->IsPositive() || spellInfo->HasEffect(SPELL_EFFECT_DISPEL))
        && (!IsHostileTo(victim))) // prevent from affecting enemy by "positive" spell
    {
        return SPELL_MISS_NONE;
    }
 
    // Check for immune
    // xinef: check for school immunity only
    if (victim->IsImmunedToSchool(spell))
    {
        return SPELL_MISS_IMMUNE;
    }
 
    if (this == victim)
    {
        return SPELL_MISS_NONE;
    }
 
    // Return evade for units in evade mode
    if (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsEvadingAttacks() && !spellInfo->HasAura(SPELL_AURA_CONTROL_VEHICLE) &&
        !spellInfo->HasAttribute(SPELL_ATTR0_CU_IGNORE_EVADE))
    {
        return SPELL_MISS_EVADE;
    }
 
    // Try victim reflect spell
    if (CanReflect)
    {
        int32 reflectchance = victim->GetTotalAuraModifier(SPELL_AURA_REFLECT_SPELLS);
        Unit::AuraEffectList const& mReflectSpellsSchool = victim->GetAuraEffectsByType(SPELL_AURA_REFLECT_SPELLS_SCHOOL);
        for (Unit::AuraEffectList::const_iterator i = mReflectSpellsSchool.begin(); i != mReflectSpellsSchool.end(); ++i)
        {
            if ((*i)->GetMiscValue() & spell->GetSpellSchoolMask())
            {
                reflectchance += (*i)->GetAmount();
            }
        }
 
        if (reflectchance > 0 && roll_chance_i(reflectchance))
        {
            // Start triggers for remove charges if need (trigger only for victim, and mark as active spell)
            //ProcDamageAndSpell(victim, PROC_FLAG_NONE, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_EX_REFLECT, 1, BASE_ATTACK, spell);
            return SPELL_MISS_REFLECT;
        }
    }
 
    switch (spellInfo->DmgClass)
    {
        case SPELL_DAMAGE_CLASS_RANGED:
        case SPELL_DAMAGE_CLASS_MELEE:
            return MeleeSpellHitResult(victim, spellInfo);
        case SPELL_DAMAGE_CLASS_NONE:
        {
            if (spellInfo->SpellFamilyName)
            {
                return SPELL_MISS_NONE;
            }
 
            // Xinef: apply DAMAGE_CLASS_MAGIC conditions to damaging DAMAGE_CLASS_NONE spells
            for (uint8 i = EFFECT_0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (spellInfo->Effects[i].Effect && spellInfo->Effects[i].Effect != SPELL_EFFECT_SCHOOL_DAMAGE)
                {
                    if (spellInfo->Effects[i].ApplyAuraName != SPELL_AURA_PERIODIC_DAMAGE)
                    {
                        return SPELL_MISS_NONE;
                    }
                }
            }
            [[fallthrough]];
        }
        case SPELL_DAMAGE_CLASS_MAGIC:
            return MagicSpellHitResult(victim, spellInfo);
    }
 
    return SPELL_MISS_NONE;
}

◆ SpellHitResult() [2/2]

SpellMissInfo Unit::SpellHitResult	(	Unit *	victim,
		SpellInfo const *	spell,
		bool	canReflect = `false`
	)

Definition at line 3412 of file Unit.cpp.

{
    // Check for immune
    if (victim->IsImmunedToSpell(spell))
        return SPELL_MISS_IMMUNE;
 
    // All positive spells can`t miss
    // TODO: client not show miss log for this spells - so need find info for this in dbc and use it!
    if ((spell->IsPositive() || spell->HasEffect(SPELL_EFFECT_DISPEL))
            && (!IsHostileTo(victim))) // prevent from affecting enemy by "positive" spell
        return SPELL_MISS_NONE;
 
    // Check for immune
    // xinef: check for school immunity only
    if (victim->IsImmunedToSchool(spell))
        return SPELL_MISS_IMMUNE;
 
    if (this == victim)
        return SPELL_MISS_NONE;
 
    // Return evade for units in evade mode
    if (victim->GetTypeId() == TYPEID_UNIT && victim->ToCreature()->IsEvadingAttacks() && !spell->HasAura(SPELL_AURA_CONTROL_VEHICLE) && !spell->HasAttribute(SPELL_ATTR0_CU_IGNORE_EVADE))
        return SPELL_MISS_EVADE;
 
    // Try victim reflect spell
    if (CanReflect)
    {
        int32 reflectchance = victim->GetTotalAuraModifier(SPELL_AURA_REFLECT_SPELLS);
        Unit::AuraEffectList const& mReflectSpellsSchool = victim->GetAuraEffectsByType(SPELL_AURA_REFLECT_SPELLS_SCHOOL);
        for (Unit::AuraEffectList::const_iterator i = mReflectSpellsSchool.begin(); i != mReflectSpellsSchool.end(); ++i)
            if ((*i)->GetMiscValue() & spell->GetSchoolMask())
                reflectchance += (*i)->GetAmount();
        if (reflectchance > 0 && roll_chance_i(reflectchance))
        {
            // Start triggers for remove charges if need (trigger only for victim, and mark as active spell)
            //ProcDamageAndSpell(victim, PROC_FLAG_NONE, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_EX_REFLECT, 1, BASE_ATTACK, spell);
            return SPELL_MISS_REFLECT;
        }
    }
 
    switch (spell->DmgClass)
    {
        case SPELL_DAMAGE_CLASS_RANGED:
        case SPELL_DAMAGE_CLASS_MELEE:
            return MeleeSpellHitResult(victim, spell);
        case SPELL_DAMAGE_CLASS_NONE:
            {
                if (spell->SpellFamilyName)
                {
                    return SPELL_MISS_NONE;
                }
                // Xinef: apply DAMAGE_CLASS_MAGIC conditions to damaging DAMAGE_CLASS_NONE spells
                for (uint8 i = EFFECT_0; i < MAX_SPELL_EFFECTS; ++i)
                    if (spell->Effects[i].Effect && spell->Effects[i].Effect != SPELL_EFFECT_SCHOOL_DAMAGE)
                        if (spell->Effects[i].ApplyAuraName != SPELL_AURA_PERIODIC_DAMAGE)
                            return SPELL_MISS_NONE;
                [[fallthrough]];
            }
        case SPELL_DAMAGE_CLASS_MAGIC:
            return MagicSpellHitResult(victim, spell);
    }
    return SPELL_MISS_NONE;
}

◆ SpellPctDamageModsDone()

float Unit::SpellPctDamageModsDone	(	Unit *	victim,
		SpellInfo const *	spellProto,
		DamageEffectType	damagetype
	)

Definition at line 11228 of file Unit.cpp.

{
    if (!spellProto || !victim || damagetype == DIRECT_DAMAGE)
        return 1.0f;
 
    // Some spells don't benefit from done mods
    if (spellProto->HasAttribute(SPELL_ATTR3_IGNORE_CASTER_MODIFIERS))
        return 1.0f;
 
    // For totems get damage bonus from owner
    if (GetTypeId() == TYPEID_UNIT)
    {
        if (IsTotem())
        {
            if (Unit* owner = GetOwner())
                return owner->SpellPctDamageModsDone(victim, spellProto, damagetype);
        }
        // Dancing Rune Weapon...
        else if (GetEntry() == 27893)
        {
            if (Unit* owner = GetOwner())
                return owner->SpellPctDamageModsDone(victim, spellProto, damagetype);
        }
    }
 
    // Done total percent damage auras
    float DoneTotalMod = 1.0f;
 
    AuraEffectList const& mModDamagePercentDone = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
    for (AuraEffectList::const_iterator i = mModDamagePercentDone.begin(); i != mModDamagePercentDone.end(); ++i)
    {
        // prevent apply mods from weapon specific case to non weapon specific spells (Example: thunder clap and two-handed weapon specialization)
        if (spellProto->EquippedItemClass == -1 && (*i)->GetSpellInfo()->EquippedItemClass != -1 &&
            !(*i)->GetSpellInfo()->HasAttribute(SPELL_ATTR5_AURA_AFFECTS_NOT_JUST_REQ_EQUIPED_ITEM) && (*i)->GetMiscValue() == SPELL_SCHOOL_MASK_NORMAL)
        {
            continue;
        }
 
        if (!spellProto->ValidateAttribute6SpellDamageMods(this, *i, damagetype == DOT))
            continue;
 
        if (!sScriptMgr->IsNeedModSpellDamagePercent(this, *i, DoneTotalMod, spellProto))
            continue;
 
        if ((*i)->GetMiscValue() & spellProto->GetSchoolMask())
        {
            if ((*i)->GetSpellInfo()->EquippedItemClass == -1)
                AddPct(DoneTotalMod, (*i)->GetAmount());
            else if (!(*i)->GetSpellInfo()->HasAttribute(SPELL_ATTR5_AURA_AFFECTS_NOT_JUST_REQ_EQUIPED_ITEM) && ((*i)->GetSpellInfo()->EquippedItemSubClassMask == 0))
                AddPct(DoneTotalMod, (*i)->GetAmount());
            else if (ToPlayer() && ToPlayer()->HasItemFitToSpellRequirements((*i)->GetSpellInfo()))
                AddPct(DoneTotalMod, (*i)->GetAmount());
        }
    }
 
    uint32 creatureTypeMask = victim->GetCreatureTypeMask();
    AuraEffectList const& mDamageDoneVersus = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS);
    for (AuraEffectList::const_iterator i = mDamageDoneVersus.begin(); i != mDamageDoneVersus.end(); ++i)
        if ((creatureTypeMask & uint32((*i)->GetMiscValue())) && spellProto->ValidateAttribute6SpellDamageMods(this, *i, damagetype == DOT))
            AddPct(DoneTotalMod, (*i)->GetAmount());
 
    // bonus against aurastate
    AuraEffectList const& mDamageDoneVersusAurastate = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE_VERSUS_AURASTATE);
    for (AuraEffectList::const_iterator i = mDamageDoneVersusAurastate.begin(); i != mDamageDoneVersusAurastate.end(); ++i)
        if (victim->HasAuraState(AuraStateType((*i)->GetMiscValue())) && spellProto->ValidateAttribute6SpellDamageMods(this, *i, damagetype == DOT))
            AddPct(DoneTotalMod, (*i)->GetAmount());
 
    // done scripted mod (take it from owner)
    Unit* owner = GetOwner() ? GetOwner() : this;
    AuraEffectList const& mOverrideClassScript = owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
    for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
    {
        // Xinef: self cast is ommited (because of Rage of Rivendare)
        if (!spellProto->ValidateAttribute6SpellDamageMods(this, *i, damagetype == DOT))
            continue;
 
        // xinef: Molten Fury should work on all spells
        switch ((*i)->GetMiscValue())
        {
            case 4920: // Molten Fury
            case 4919:
                if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
                    AddPct(DoneTotalMod, (*i)->GetAmount());
                break;
        }
 
        if (!(*i)->IsAffectedOnSpell(spellProto))
            continue;
 
        switch ((*i)->GetMiscValue())
        {
            case 6917: // Death's Embrace
            case 6926:
            case 6928:
                {
                    if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                    break;
                }
            // Soul Siphon
            case 4992:
            case 4993:
                {
                    // effect 1 m_amount
                    int32 maxPercent = (*i)->GetAmount();
                    // effect 0 m_amount
                    int32 stepPercent = CalculateSpellDamage(this, (*i)->GetSpellInfo(), 0);
                    // count affliction effects and calc additional damage in percentage
                    int32 modPercent = 0;
                    AuraApplicationMap const& victimAuras = victim->GetAppliedAuras();
                    for (AuraApplicationMap::const_iterator itr = victimAuras.begin(); itr != victimAuras.end(); ++itr)
                    {
                        Aura const* aura = itr->second->GetBase();
                        SpellInfo const* m_spell = aura->GetSpellInfo();
                        if (m_spell->SpellFamilyName != SPELLFAMILY_WARLOCK || !(m_spell->SpellFamilyFlags[1] & 0x0004071B || m_spell->SpellFamilyFlags[0] & 0x8044C402))
                            continue;
                        modPercent += stepPercent * aura->GetStackAmount();
                        if (modPercent >= maxPercent)
                        {
                            modPercent = maxPercent;
                            break;
                        }
                    }
                    AddPct(DoneTotalMod, modPercent);
                    break;
                }
            case 6916: // Death's Embrace
            case 6925:
            case 6927:
                if (HasAuraState(AURA_STATE_HEALTHLESS_20_PERCENT, spellProto, this))
                    AddPct(DoneTotalMod, (*i)->GetAmount());
                break;
            case 5481: // Starfire Bonus
                {
                    if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, 0x200002, 0, 0))
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                    break;
                }
            // Tundra Stalker
            // Merciless Combat
            case 7277:
                {
                    // Merciless Combat
                    if ((*i)->GetSpellInfo()->SpellIconID == 2656)
                    {
                        if( (spellProto && spellProto->SpellFamilyFlags[0] & 0x2) || spellProto->SpellFamilyFlags[1] & 0x2 )
                            if (!victim->HealthAbovePct(35))
                                AddPct(DoneTotalMod, (*i)->GetAmount());
                    }
                    // Tundra Stalker
                    else
                    {
                        // Frost Fever (target debuff)
                        if (victim->HasAura(55095))
                            AddPct(DoneTotalMod, (*i)->GetAmount());
                        break;
                    }
                    break;
                }
            // Rage of Rivendare
            case 7293:
                {
                    if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DEATHKNIGHT, 0, 0x02000000, 0))
                        AddPct(DoneTotalMod, (*i)->GetSpellInfo()->GetRank() * 2.0f);
                    break;
                }
            // Twisted Faith
            case 7377:
                {
                    if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID()))
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                    break;
                }
            // Marked for Death
            case 7598:
            case 7599:
            case 7600:
            case 7601:
            case 7602:
                {
                    if (victim->GetAuraEffect(SPELL_AURA_MOD_STALKED, SPELLFAMILY_HUNTER, 0x400, 0, 0))
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                    break;
                }
            // Dirty Deeds
            case 6427:
            case 6428:
            case 6579:
            case 6580:
                {
                    if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, this))
                    {
                        // effect 0 has expected value but in negative state
                        int32 bonus = -(*i)->GetBase()->GetEffect(0)->GetAmount();
                        AddPct(DoneTotalMod, bonus);
                    }
                    break;
                }
        }
    }
 
    // Custom scripted damage
    switch (spellProto->SpellFamilyName)
    {
        case SPELLFAMILY_MAGE:
            // Ice Lance
            if (spellProto->SpellIconID == 186)
            {
                if (victim->HasAuraState(AURA_STATE_FROZEN, spellProto, this))
                {
                    // Glyph of Ice Lance
                    if (owner->HasAura(56377) && victim->getLevel() > owner->getLevel())
                        DoneTotalMod *= 4.0f;
                    else
                        DoneTotalMod *= 3.0f;
                }
            }
 
            // Torment the weak
            if (spellProto->SpellFamilyFlags[0] & 0x20600021 || spellProto->SpellFamilyFlags[1] & 0x9000)
                if (victim->HasAuraWithMechanic((1 << MECHANIC_SNARE) | (1 << MECHANIC_SLOW_ATTACK)))
                    if (AuraEffect* aurEff = GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_GENERIC, 3263, EFFECT_0))
                        AddPct(DoneTotalMod, aurEff->GetAmount());
            break;
        case SPELLFAMILY_PRIEST:
            // Mind Flay
            if (spellProto->SpellFamilyFlags[0] & 0x800000)
            {
                // Glyph of Shadow Word: Pain
                if (AuraEffect* aurEff = GetAuraEffect(55687, 0))
                    // Increase Mind Flay damage if Shadow Word: Pain present on target
                    if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID()))
                        AddPct(DoneTotalMod, aurEff->GetAmount());
 
                // Twisted Faith - Mind Flay part
                if (AuraEffect* aurEff = GetAuraEffect(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS, SPELLFAMILY_PRIEST, 2848, 1))
                    // Increase Mind Flay damage if Shadow Word: Pain present on target
                    if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID()))
                        AddPct(DoneTotalMod, aurEff->GetAmount());
            }
            // Smite
            else if (spellProto->SpellFamilyFlags[0] & 0x80)
            {
                // Glyph of Smite
                if (AuraEffect* aurEff = GetAuraEffect(55692, 0))
                    if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x100000, 0, 0, GetGUID()))
                        AddPct(DoneTotalMod, aurEff->GetAmount());
            }
            // Shadow Word: Death
            else if (spellProto->SpellFamilyFlags[1] & 0x2)
            {
                // Glyph of Shadow Word: Death
                if (AuraEffect* aurEff = GetAuraEffect(55682, 1))
                    if (victim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT))
                        AddPct(DoneTotalMod, aurEff->GetAmount());
            }
 
            break;
        case SPELLFAMILY_PALADIN:
            // Judgement of Vengeance/Judgement of Corruption
            if ((spellProto->SpellFamilyFlags[1] & 0x400000) && spellProto->SpellIconID == 2292)
            {
                // Get stack of Holy Vengeance/Blood Corruption on the target added by caster
                uint32 stacks = 0;
                Unit::AuraEffectList const& auras = victim->GetAuraEffectsByType(SPELL_AURA_PERIODIC_DAMAGE);
                for (Unit::AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end(); ++itr)
                    if (((*itr)->GetId() == 31803 || (*itr)->GetId() == 53742) && (*itr)->GetCasterGUID() == GetGUID())
                    {
                        stacks = (*itr)->GetBase()->GetStackAmount();
                        break;
                    }
                // + 10% for each application of Holy Vengeance/Blood Corruption on the target
                if (stacks)
                    AddPct(DoneTotalMod, 10 * stacks);
            }
            break;
        case SPELLFAMILY_DRUID:
            // Thorns
            if (spellProto->SpellFamilyFlags[0] & 0x100)
            {
                // Brambles
                if (AuraEffect* aurEff = GetAuraEffectOfRankedSpell(16836, 0))
                    AddPct(DoneTotalMod, aurEff->GetAmount());
            }
            break;
        case SPELLFAMILY_WARLOCK:
            // Fire and Brimstone
            if (spellProto->SpellFamilyFlags[1] & 0x00020040)
                if (victim->HasAuraState(AURA_STATE_CONFLAGRATE))
                {
                    AuraEffectList const& mDumyAuras = GetAuraEffectsByType(SPELL_AURA_DUMMY);
                    for (AuraEffectList::const_iterator i = mDumyAuras.begin(); i != mDumyAuras.end(); ++i)
                        if ((*i)->GetSpellInfo()->SpellIconID == 3173)
                        {
                            AddPct(DoneTotalMod, (*i)->GetAmount());
                            break;
                        }
                }
            // Drain Soul - increased damage for targets under 25 % HP
            if (spellProto->SpellFamilyFlags[0] & 0x00004000)
                if (!victim->HealthAbovePct(25))
                    DoneTotalMod *= 4;
            // Shadow Bite (15% increase from each dot)
            if (spellProto->SpellFamilyFlags[1] & 0x00400000 && IsPet())
                if (uint8 count = victim->GetDoTsByCaster(GetOwnerGUID()))
                    AddPct(DoneTotalMod, 15 * count);
            break;
        case SPELLFAMILY_HUNTER:
            // Steady Shot
            if (spellProto->SpellFamilyFlags[1] & 0x1)
                if (AuraEffect* aurEff = GetAuraEffect(56826, 0))  // Glyph of Steady Shot
                    if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_HUNTER, 0x00004000, 0, 0, GetGUID()))
                        AddPct(DoneTotalMod, aurEff->GetAmount());
            break;
        case SPELLFAMILY_DEATHKNIGHT:
            // Improved Icy Touch
            if (spellProto->SpellFamilyFlags[0] & 0x2)
                if (AuraEffect* aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 2721, 0))
                    AddPct(DoneTotalMod, aurEff->GetAmount());
 
            // Glacier Rot
            if (spellProto->SpellFamilyFlags[0] & 0x2 || spellProto->SpellFamilyFlags[1] & 0x6)
                if (AuraEffect* aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 196, 0))
                    if (victim->GetDiseasesByCaster(owner->GetGUID()) > 0)
                        AddPct(DoneTotalMod, aurEff->GetAmount());
            break;
    }
 
    return DoneTotalMod;
}

◆ SpellPctHealingModsDone()

float Unit::SpellPctHealingModsDone	(	Unit *	victim,
		SpellInfo const *	spellProto,
		DamageEffectType	damagetype
	)

Definition at line 12271 of file Unit.cpp.

{
    // For totems get healing bonus from owner (statue isn't totem in fact)
    if (GetTypeId() == TYPEID_UNIT && IsTotem())
        if (Unit* owner = GetOwner())
            return owner->SpellPctHealingModsDone(victim, spellProto, damagetype);
 
    // Some spells don't benefit from done mods
    if (spellProto->HasAttribute(SPELL_ATTR3_IGNORE_CASTER_MODIFIERS))
        return 1.0f;
 
    // xinef: Some spells don't benefit from done mods
    if (spellProto->HasAttribute(SPELL_ATTR6_IGNORE_HEALTH_MODIFIERS))
        return 1.0f;
 
    // No bonus healing for potion spells
    if (spellProto->SpellFamilyName == SPELLFAMILY_POTION)
        return 1.0f;
 
    float DoneTotalMod = 1.0f;
 
    // Healing done percent
    AuraEffectList const& mHealingDonePct = GetAuraEffectsByType(SPELL_AURA_MOD_HEALING_DONE_PERCENT);
    for (auto const& auraEff : mHealingDonePct)
    {
        if (!sScriptMgr->IsNeedModHealPercent(this, auraEff, DoneTotalMod, spellProto))
            continue;
 
        AddPct(DoneTotalMod, auraEff->GetAmount());
    }
 
    // done scripted mod (take it from owner)
    Unit* owner = GetOwner() ? GetOwner() : this;
    AuraEffectList const& mOverrideClassScript = owner->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
    for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
    {
        if (!(*i)->IsAffectedOnSpell(spellProto))
            continue;
 
        switch ((*i)->GetMiscValue())
        {
            case   21: // Test of Faith
            case 6935:
            case 6918:
                if (victim->HealthBelowPct(50))
                    AddPct(DoneTotalMod, (*i)->GetAmount());
                break;
            case 7798: // Glyph of Regrowth
                {
                    if (victim->GetAuraEffect(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_DRUID, 0x40, 0, 0))
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                    break;
                }
 
            case 7871: // Glyph of Lesser Healing Wave
                {
                    // xinef: affected by any earth shield
                    if (victim->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, 0, 0x00000400, 0))
                        AddPct(DoneTotalMod, (*i)->GetAmount());
                    break;
                }
            default:
                break;
        }
    }
 
    switch (spellProto->SpellFamilyName)
    {
        case SPELLFAMILY_GENERIC:
            // Talents and glyphs for healing stream totem
            if (spellProto->Id == 52042)
            {
                // Glyph of Healing Stream Totem
                if (AuraEffect* dummy = owner->GetAuraEffect(55456, EFFECT_0))
                    AddPct(DoneTotalMod, dummy->GetAmount());
 
                // Healing Stream totem - Restorative Totems
                if (AuraEffect* aurEff = GetDummyAuraEffect(SPELLFAMILY_SHAMAN, 338, 1))
                    AddPct(DoneTotalMod, aurEff->GetAmount());
            }
            break;
        case SPELLFAMILY_PRIEST:
            // T9 HEALING 4P, empowered renew instant heal
            if (spellProto->Id == 63544)
                if (AuraEffect* aurEff = GetAuraEffect(67202, EFFECT_0))
                    AddPct(DoneTotalMod, aurEff->GetAmount());
            break;
    }
 
    return DoneTotalMod;
}

◆ SpellTakenCritChance()

float Unit::SpellTakenCritChance	(	Unit const *	caster,
		SpellInfo const *	spellProto,
		SpellSchoolMask	schoolMask,
		float	doneChance,
		WeaponAttackType	attackType,
		bool	skipEffectCheck
	)		const

Definition at line 11980 of file Unit.cpp.

{
    // not critting spell
    if (spellProto->HasAttribute(SPELL_ATTR2_CANT_CRIT))
        return 0.0f;
 
    // Xinef: check if spell is capable of critting, auras requires special aura to crit so they can be skipped
    if (!skipEffectCheck && !spellProto->IsCritCapable())
        return 0.0f;
 
    float crit_chance = doneChance;
    switch (spellProto->DmgClass)
    {
        case SPELL_DAMAGE_CLASS_MAGIC:
            {
                if (!spellProto->IsPositive())
                {
                    // Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE
                    // xinef: apply max and min only
                    if (HasAuraType(SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE))
                    {
                        crit_chance += GetMaxNegativeAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE, schoolMask);
                        crit_chance += GetMaxPositiveAuraModifierByMiscMask(SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE, schoolMask);
                    }
 
                    Unit::ApplyResilience(this, &crit_chance, nullptr, false, CR_CRIT_TAKEN_SPELL);
                }
                // scripted (increase crit chance ... against ... target by x%
                if (caster)
                {
                    AuraEffectList const& mOverrideClassScript = caster->GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
                    for (AuraEffectList::const_iterator i = mOverrideClassScript.begin(); i != mOverrideClassScript.end(); ++i)
                    {
                        if (!((*i)->IsAffectedOnSpell(spellProto)))
                            continue;
                        int32 modChance = 0;
                        switch ((*i)->GetMiscValue())
                        {
                            // Shatter
                            case 911:
                                modChance += 16;
                                [[fallthrough]];
                            case 910:
                                modChance += 17;
                                [[fallthrough]];
                            case 849:
                                modChance += 17;
                                if (!HasAuraState(AURA_STATE_FROZEN, spellProto, caster))
                                    break;
                                crit_chance += modChance;
                                break;
                            case 7917: // Glyph of Shadowburn
                                if (HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, spellProto, caster))
                                    crit_chance += (*i)->GetAmount();
                                break;
                            case 7997: // Renewed Hope
                            case 7998:
                                if (HasAura(6788))
                                    crit_chance += (*i)->GetAmount();
                                break;
                            default:
                                break;
                        }
                    }
                    // Custom crit by class
                    switch (spellProto->SpellFamilyName)
                    {
                        case SPELLFAMILY_MAGE:
                            // Glyph of Fire Blast
                            if (spellProto->SpellFamilyFlags[0] == 0x2 && spellProto->SpellIconID == 12)
                                if (HasAuraWithMechanic((1 << MECHANIC_STUN) | (1 << MECHANIC_KNOCKOUT)))
                                    if (AuraEffect const* aurEff = caster->GetAuraEffect(56369, EFFECT_0))
                                        crit_chance += aurEff->GetAmount();
                            break;
                        case SPELLFAMILY_DRUID:
                            // Improved Faerie Fire
                            if (HasAuraState(AURA_STATE_FAERIE_FIRE))
                                if (AuraEffect const* aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_DRUID, 109, 0))
                                    crit_chance += aurEff->GetAmount();
 
                            // cumulative effect - don't break
 
                            // Starfire
                            if (spellProto->SpellFamilyFlags[0] & 0x4 && spellProto->SpellIconID == 1485)
                            {
                                // Improved Insect Swarm
                                if (AuraEffect const* aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_DRUID, 1771, 0))
                                    if (GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, 0x00000002, 0, 0))
                                        crit_chance += aurEff->GetAmount();
                                break;
                            }
                            break;
                        case SPELLFAMILY_ROGUE:
                            // Shiv-applied poisons can't crit
                            if (caster->FindCurrentSpellBySpellId(5938))
                                crit_chance = 0.0f;
                            break;
                        case SPELLFAMILY_PALADIN:
                            // Flash of light
                            if (spellProto->SpellFamilyFlags[0] & 0x40000000)
                            {
                                // Sacred Shield
                                if (AuraEffect const* aura = GetAuraEffect(58597, 1, GetGUID()))
                                    crit_chance += aura->GetAmount();
                                break;
                            }
                            // Exorcism
                            else if (spellProto->GetCategory() == 19)
                            {
                                if (GetCreatureTypeMask() & CREATURE_TYPEMASK_DEMON_OR_UNDEAD)
                                    return 100.0f;
                                break;
                            }
                            break;
                        case SPELLFAMILY_SHAMAN:
                            // Lava Burst
                            if (spellProto->SpellFamilyFlags[1] & 0x00001000)
                            {
                                if (GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_SHAMAN, 0x10000000, 0, 0, caster->GetGUID()))
                                    if (GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE) > -100)
                                        return 100.0f;
                                break;
                            }
                            break;
                    }
                }
                break;
            }
        case SPELL_DAMAGE_CLASS_MELEE:
            // Custom crit by class
            if (caster)
            {
                switch (spellProto->SpellFamilyName)
                {
                case SPELLFAMILY_DRUID:
                    // Rend and Tear - bonus crit chance for Ferocious Bite on bleeding targets
                    if (spellProto->SpellFamilyFlags[0] & 0x00800000 && spellProto->SpellIconID == 1680 && HasAuraState(AURA_STATE_BLEEDING))
                    {
                        if (AuraEffect const* rendAndTear = caster->GetDummyAuraEffect(SPELLFAMILY_DRUID, 2859, 1))
                            crit_chance += rendAndTear->GetAmount();
                        break;
                    }
                    break;
                case SPELLFAMILY_WARRIOR:
                    // Victory Rush
                    if (spellProto->SpellFamilyFlags[1] & 0x100)
                    {
                        // Glyph of Victory Rush
                        if (AuraEffect const* aurEff = caster->GetAuraEffect(58382, 0))
                            crit_chance += aurEff->GetAmount();
                        break;
                    }
                    break;
                }
            }
 
            // 100% critical chance against sitting target
            if (GetTypeId() == TYPEID_PLAYER && (IsSitState() || getStandState() == UNIT_STAND_STATE_SLEEP))
            {
                return 100.0f;
            }
            [[fallthrough]]; // TODO: Not sure whether the fallthrough was a mistake (forgetting a break) or intended. This should be double-checked.
        case SPELL_DAMAGE_CLASS_RANGED:
            {
                // flat aura mods
                if (attackType == RANGED_ATTACK)
                    crit_chance += GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_CHANCE);
                else
                    crit_chance += GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_CHANCE);
 
                // reduce crit chance from Rating for players
                if (attackType != RANGED_ATTACK)
                {
                    // xinef: little hack, crit chance dont require caster to calculate, pass victim
                    Unit::ApplyResilience(this, &crit_chance, nullptr, false, CR_CRIT_TAKEN_MELEE);
                }
                else
                    Unit::ApplyResilience(this, &crit_chance, nullptr, false, CR_CRIT_TAKEN_RANGED);
 
                // Apply crit chance from defence skill
                if (caster)
                    crit_chance += (int32(caster->GetMaxSkillValueForLevel(this)) - int32(GetDefenseSkillValue(caster))) * 0.04f;
 
                break;
            }
        // values overridden in spellmgr for lifebloom and earth shield
        case SPELL_DAMAGE_CLASS_NONE:
        default:
            return 0.0f;
    }
 
    if (caster)
    {
        AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(SPELL_AURA_MOD_CRIT_CHANCE_FOR_CASTER);
        for (AuraEffectList::const_iterator i = mTotalAuraList.begin(); i != mTotalAuraList.end(); ++i)
        {
            if (caster->GetGUID() != (*i)->GetCasterGUID())
                continue;
 
            crit_chance += (*i)->GetAmount();
        }
    }
 
    // Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE
    // xinef: should be calculated at the end
    if (!spellProto->IsPositive())
        crit_chance += GetTotalAuraModifier(SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
 
    // xinef: can be negative!
    return crit_chance;
}

◆ StartReactiveTimer()

void Unit::StartReactiveTimer ( ReactiveType reactive )

inline

Definition at line 2308 of file Unit.h.

2308{ m_reactiveTimer[reactive] = REACTIVE_TIMER_START;}

REACTIVE_TIMER_START

#define REACTIVE_TIMER_START

Definition: Unit.h:1198

◆ StopAttackFaction()

void Unit::StopAttackFaction ( uint32 faction_id )

Definition at line 20173 of file Unit.cpp.

{
    if (Unit* victim = GetVictim())
    {
        if (victim->GetFactionTemplateEntry()->faction == faction_id)
        {
            AttackStop();
            if (IsNonMeleeSpellCast(false))
                InterruptNonMeleeSpells(false);
 
            // melee and ranged forced attack cancel
            if (GetTypeId() == TYPEID_PLAYER)
                ToPlayer()->SendAttackSwingCancelAttack();
        }
    }
 
    AttackerSet const& attackers = getAttackers();
    for (AttackerSet::const_iterator itr = attackers.begin(); itr != attackers.end();)
    {
        if ((*itr)->GetFactionTemplateEntry()->faction == faction_id)
        {
            (*itr)->AttackStop();
            itr = attackers.begin();
        }
        else
            ++itr;
    }
 
    getHostileRefMgr().deleteReferencesForFaction(faction_id);
 
    for (ControlSet::const_iterator itr = m_Controlled.begin(); itr != m_Controlled.end(); ++itr)
        (*itr)->StopAttackFaction(faction_id);
}

◆ StopAttackingInvalidTarget()

void Unit::StopAttackingInvalidTarget ( )

Definition at line 20207 of file Unit.cpp.

{
    AttackerSet const& attackers = getAttackers();
    for (AttackerSet::const_iterator itr = attackers.begin(); itr != attackers.end();)
    {
        Unit* attacker = (*itr);
        if (!attacker->IsValidAttackTarget(this))
        {
            attacker->AttackStop();
            if (attacker->GetTypeId() == TYPEID_PLAYER)
            {
                attacker->ToPlayer()->SendAttackSwingCancelAttack();
            }
 
            for (Unit* controled : attacker->m_Controlled)
            {
                if (controled->GetVictim() == this && !controled->IsValidAttackTarget(this))
                {
                    controled->AttackStop();
                }
            }
 
            itr = attackers.begin();
        }
        else
        {
            ++itr;
        }
    }
}

◆ StopMoving()

void Unit::StopMoving ( )

Definition at line 16736 of file Unit.cpp.

{
    ClearUnitState(UNIT_STATE_MOVING);
 
    // not need send any packets if not in world or not moving
    if (!IsInWorld())
        return;
 
    if (movespline->Finalized())
        return;
 
    // Update position now since Stop does not start a new movement that can be updated later
    if (movespline->HasStarted())
        UpdateSplinePosition();
 
    Movement::MoveSplineInit init(this);
    init.Stop();
}

◆ StopMovingOnCurrentPos()

void Unit::StopMovingOnCurrentPos ( )

Definition at line 16775 of file Unit.cpp.

{
    ClearUnitState(UNIT_STATE_MOVING);
 
    // not need send any packets if not in world
    if (!IsInWorld())
        return;
 
    DisableSpline(); // pussywizard: required so Launch() won't recalculate position from previous spline
    Movement::MoveSplineInit init(this);
    init.MoveTo(GetPositionX(), GetPositionY(), GetPositionZ());
    init.SetFacing(GetOrientation());
    init.Launch();
}

◆ Talk() [1/2]

void Unit::Talk	(	std::string_view	text,
		ChatMsg	msgType,
		Language	language,
		float	textRange,
		WorldObject const *	target
	)

virtual

Definition at line 21135 of file Unit.cpp.

{
    Acore::CustomChatTextBuilder builder(this, msgType, text, language, target);
    Acore::LocalizedPacketDo<Acore::CustomChatTextBuilder> localizer(builder);
    Acore::PlayerDistWorker<Acore::LocalizedPacketDo<Acore::CustomChatTextBuilder> > worker(this, textRange, localizer);
    Cell::VisitWorldObjects(this, worker, textRange);
}

◆ Talk() [2/2]

void Unit::Talk	(	uint32	textId,
		ChatMsg	msgType,
		float	textRange,
		WorldObject const *	target
	)

virtual

Definition at line 21171 of file Unit.cpp.

{
    if (!sObjectMgr->GetBroadcastText(textId))
    {
        LOG_ERROR("entities.unit", "Unit::Talk: `broadcast_text` (ID: {}) was not found", textId);
        return;
    }
 
    Acore::BroadcastTextBuilder builder(this, msgType, textId, getGender(), target);
    Acore::LocalizedPacketDo<Acore::BroadcastTextBuilder> localizer(builder);
    Acore::PlayerDistWorker<Acore::LocalizedPacketDo<Acore::BroadcastTextBuilder> > worker(this, textRange, localizer);
    Cell::VisitWorldObjects(this, worker, textRange);
}

◆ TauntApply()

void Unit::TauntApply ( Unit * victim )

Definition at line 14534 of file Unit.cpp.

{
    ASSERT(GetTypeId() == TYPEID_UNIT);
 
    if (!taunter || (taunter->GetTypeId() == TYPEID_PLAYER && taunter->ToPlayer()->IsGameMaster()))
        return;
 
    if (!CanHaveThreatList())
        return;
 
    Creature* creature = ToCreature();
 
    if (creature->HasReactState(REACT_PASSIVE))
        return;
 
    Unit* target = GetVictim();
    if (target && target == taunter)
        return;
 
    SetInFront(taunter);
    if (creature->IsAIEnabled)
        creature->AI()->AttackStart(taunter);
 
    //m_ThreatMgr.tauntApply(taunter);
}

◆ TauntFadeOut()

void Unit::TauntFadeOut ( Unit * taunter )

Definition at line 14562 of file Unit.cpp.

{
    ASSERT(GetTypeId() == TYPEID_UNIT);
 
    if (!taunter || (taunter->GetTypeId() == TYPEID_PLAYER && taunter->ToPlayer()->IsGameMaster()))
        return;
 
    if (!CanHaveThreatList())
        return;
 
    Creature* creature = ToCreature();
 
    if (creature->HasReactState(REACT_PASSIVE))
        return;
 
    Unit* target = GetVictim();
    if (!target || target != taunter)
        return;
 
    if (m_ThreatMgr.isThreatListEmpty())
    {
        if (creature->IsAIEnabled)
            creature->AI()->EnterEvadeMode(CreatureAI::EVADE_REASON_NO_HOSTILES);
        return;
    }
 
    target = creature->SelectVictim();  // might have more taunt auras remaining
 
    if (target && target != taunter)
    {
        SetInFront(target);
        if (creature->IsAIEnabled)
            creature->AI()->AttackStart(target);
    }
}

◆ TextEmote() [1/2]

void Unit::TextEmote	(	std::string_view	text,
		WorldObject const *	target = `nullptr`,
		bool	isBossEmote = `false`
	)

virtual

Reimplemented in Player.

Definition at line 21153 of file Unit.cpp.

{
    Talk(text, isBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, LANG_UNIVERSAL, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE), target);
}

◆ TextEmote() [2/2]

void Unit::TextEmote	(	uint32	textId,
		WorldObject const *	target = `nullptr`,
		bool	isBossEmote = `false`
	)

virtual

Reimplemented in Player.

Definition at line 21195 of file Unit.cpp.

{
    Talk(textId, isBossEmote ? CHAT_MSG_RAID_BOSS_EMOTE : CHAT_MSG_MONSTER_EMOTE, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE), target);
}

◆ ToPet()

Pet * Unit::ToPet ( )

inline

Definition at line 2393 of file Unit.h.

2393{ if (IsPet()) return reinterpret_cast<Pet*>(this); else return nullptr; }

◆ ToTempSummon() [1/2]

TempSummon * Unit::ToTempSummon ( )

inline

Definition at line 2395 of file Unit.h.

2395{ if (IsSummon()) return reinterpret_cast<TempSummon*>(this); else return nullptr; }

◆ ToTempSummon() [2/2]

const TempSummon * Unit::ToTempSummon ( ) const

inline

Definition at line 2396 of file Unit.h.

2396{ if (IsSummon()) return reinterpret_cast<const TempSummon*>(this); else return nullptr; }

◆ ToTotem()

Totem * Unit::ToTotem ( )

inline

Definition at line 2394 of file Unit.h.

2394{ if (IsTotem()) return reinterpret_cast<Totem*>(this); else return nullptr; }

Totem

Definition: Totem.h:38

◆ TriggerAurasProcOnEvent() [1/3]

void Unit::TriggerAurasProcOnEvent ( CalcDamageInfo & damageInfo )

Definition at line 16647 of file Unit.cpp.

{
    DamageInfo dmgInfo = DamageInfo(damageInfo);
    TriggerAurasProcOnEvent(nullptr, nullptr, damageInfo.target, damageInfo.procAttacker, damageInfo.procVictim, 0, 0, damageInfo.procEx, nullptr, &dmgInfo, nullptr);
}

◆ TriggerAurasProcOnEvent() [2/3]

void Unit::TriggerAurasProcOnEvent	(	ProcEventInfo &	eventInfo,
		std::list< AuraApplication * > &	procAuras
	)

Definition at line 16672 of file Unit.cpp.

{
    for (std::list<AuraApplication*>::iterator itr = aurasTriggeringProc.begin(); itr != aurasTriggeringProc.end(); ++itr)
    {
        if (!(*itr)->GetRemoveMode())
            (*itr)->GetBase()->TriggerProcOnEvent(*itr, eventInfo);
    }
}

◆ TriggerAurasProcOnEvent() [3/3]

void Unit::TriggerAurasProcOnEvent	(	std::list< AuraApplication * > *	myProcAuras,
		std::list< AuraApplication * > *	targetProcAuras,
		Unit *	actionTarget,
		uint32	typeMaskActor,
		uint32	typeMaskActionTarget,
		uint32	spellTypeMask,
		uint32	spellPhaseMask,
		uint32	hitMask,
		Spell *	spell,
		DamageInfo *	damageInfo,
		HealInfo *	healInfo
	)

Definition at line 16653 of file Unit.cpp.

{
    // prepare data for self trigger
    ProcEventInfo myProcEventInfo = ProcEventInfo(this, actionTarget, actionTarget, typeMaskActor, spellTypeMask, spellPhaseMask, hitMask, spell, damageInfo, healInfo);
    std::list<AuraApplication*> myAurasTriggeringProc;
    GetProcAurasTriggeredOnEvent(myAurasTriggeringProc, myProcAuras, myProcEventInfo);
 
    // prepare data for target trigger
    ProcEventInfo targetProcEventInfo = ProcEventInfo(this, actionTarget, this, typeMaskActionTarget, spellTypeMask, spellPhaseMask, hitMask, spell, damageInfo, healInfo);
    std::list<AuraApplication*> targetAurasTriggeringProc;
    if (typeMaskActionTarget)
        GetProcAurasTriggeredOnEvent(targetAurasTriggeringProc, targetProcAuras, targetProcEventInfo);
 
    TriggerAurasProcOnEvent(myProcEventInfo, myAurasTriggeringProc);
 
    if (typeMaskActionTarget)
        TriggerAurasProcOnEvent(targetProcEventInfo, targetAurasTriggeringProc);
}

◆ UnsummonAllTotems()

void Unit::UnsummonAllTotems ( bool onDeath = false )

Definition at line 11153 of file Unit.cpp.

{
    for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
    {
        if (!m_SummonSlot[i])
        {
            continue;
        }
 
        if (Creature* OldTotem = GetMap()->GetCreature(m_SummonSlot[i]))
        {
            if (OldTotem->IsSummon())
            {
                if (!(onDeath && !IsPlayer() && OldTotem->IsGuardian()))
                {
                    OldTotem->ToTempSummon()->UnSummon();
                }
            }
        }
    }
}

◆ Update()

void Unit::Update ( uint32 time )

overridevirtual

Reimplemented from WorldObject.

Definition at line 402 of file Unit.cpp.

{
    sScriptMgr->OnUnitUpdate(this, p_time);
 
    // WARNING! Order of execution here is important, do not change.
    // Spells must be processed with event system BEFORE they go to _UpdateSpells.
    // Or else we may have some SPELL_STATE_FINISHED spells stalled in pointers, that is bad.
    m_Events.Update(p_time);
 
    if (!IsInWorld())
        return;
 
    // pussywizard:
    if (GetTypeId() != TYPEID_PLAYER || (!ToPlayer()->IsBeingTeleported() && !bRequestForcedVisibilityUpdate))
    {
        if (m_delayed_unit_relocation_timer)
        {
            if (m_delayed_unit_relocation_timer <= p_time)
            {
                m_delayed_unit_relocation_timer = 0;
                //ExecuteDelayedUnitRelocationEvent();
                FindMap()->i_objectsForDelayedVisibility.insert(this);
            }
            else
                m_delayed_unit_relocation_timer -= p_time;
        }
        if (m_delayed_unit_ai_notify_timer)
        {
            if (m_delayed_unit_ai_notify_timer <= p_time)
            {
                m_delayed_unit_ai_notify_timer = 0;
                ExecuteDelayedUnitAINotifyEvent();
            }
            else
                m_delayed_unit_ai_notify_timer -= p_time;
        }
    }
 
    _UpdateSpells( p_time );
 
    if (CanHaveThreatList() && GetThreatMgr().isNeedUpdateToClient(p_time))
        SendThreatListUpdate();
 
    // update combat timer only for players and pets (only pets with PetAI)
    if (IsInCombat() && (GetTypeId() == TYPEID_PLAYER || ((IsPet() || HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN)) && IsControlledByPlayer())))
    {
        // Check UNIT_STATE_MELEE_ATTACKING or UNIT_STATE_CHASE (without UNIT_STATE_FOLLOW in this case) so pets can reach far away
        // targets without stopping half way there and running off.
        // These flags are reset after target dies or another command is given.
        if (m_HostileRefMgr.IsEmpty())
        {
            // m_CombatTimer set at aura start and it will be freeze until aura removing
            if (m_CombatTimer <= p_time)
                ClearInCombat();
            else
                m_CombatTimer -= p_time;
        }
    }
 
    _lastDamagedTargetGuid = ObjectGuid::Empty;
    if (_lastExtraAttackSpell)
    {
        while (!extraAttacksTargets.empty())
        {
            auto itr = extraAttacksTargets.begin();
            ObjectGuid targetGuid = itr->first;
            uint32 count = itr->second;
            extraAttacksTargets.erase(itr);
            if (Unit* victim = ObjectAccessor::GetUnit(*this, targetGuid))
            {
                if (_lastExtraAttackSpell == SPELL_SWORD_SPECIALIZATION || _lastExtraAttackSpell == SPELL_HACK_AND_SLASH
                    || victim->IsWithinMeleeRange(this))
                {
                    HandleProcExtraAttackFor(victim, count);
                }
            }
        }
        _lastExtraAttackSpell = 0;
    }
 
    // not implemented before 3.0.2
    // xinef: if attack time > 0, reduce by diff
    // if on next update, attack time < 0 assume player didnt attack - set to 0
    bool suspendAttackTimer = false;
    bool suspendRangedAttackTimer = false;
    if (IsPlayer() && HasUnitState(UNIT_STATE_CASTING))
    {
        for (Spell* spell : m_currentSpells)
        {
            if (spell)
            {
                if (spell->GetSpellInfo()->HasAttribute(SPELL_ATTR2_DO_NOT_RESET_COMBAT_TIMERS))
                {
                    if (spell->IsChannelActive())
                    {
                        suspendRangedAttackTimer = true;
                    }
 
                    suspendAttackTimer = true;
                    break;
                }
            }
        }
    }
 
    if (!suspendAttackTimer)
    {
        if (int32 base_attack = getAttackTimer(BASE_ATTACK))
        {
            setAttackTimer(BASE_ATTACK, base_attack > 0 ? base_attack - (int32) p_time : 0);
        }
 
        if (int32 off_attack = getAttackTimer(OFF_ATTACK))
        {
            setAttackTimer(OFF_ATTACK, off_attack > 0 ? off_attack - (int32) p_time : 0);
        }
    }
 
    if (!suspendRangedAttackTimer)
    {
        if (int32 ranged_attack = getAttackTimer(RANGED_ATTACK))
        {
            setAttackTimer(RANGED_ATTACK, ranged_attack > 0 ? ranged_attack - (int32)p_time : 0);
        }
    }
 
    // update abilities available only for fraction of time
    UpdateReactives(p_time);
 
    ModifyAuraState(AURA_STATE_HEALTHLESS_20_PERCENT, IsAlive() ? HealthBelowPct(20) : false);
    ModifyAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, IsAlive() ? HealthBelowPct(35) : false);
    ModifyAuraState(AURA_STATE_HEALTH_ABOVE_75_PERCENT, IsAlive() ? HealthBelowPct(75) : false);
 
    UpdateSplineMovement(p_time);
    GetMotionMaster()->UpdateMotion(p_time);
}

◆ UpdateAllResistances()

void Unit::UpdateAllResistances ( )

virtual

Definition at line 54 of file StatSystem.cpp.

{
    for (uint8 i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
        UpdateResistances(i);
}

◆ UpdateAllStats()

virtual bool Unit::UpdateAllStats ( )

pure virtual

Implemented in Creature, Guardian, Player, and Totem.

◆ UpdateArmor()

virtual void Unit::UpdateArmor ( )

pure virtual

Implemented in Creature, Guardian, Player, and Totem.

◆ UpdateAttackPowerAndDamage()

virtual void Unit::UpdateAttackPowerAndDamage ( bool ranged = false )

pure virtual

Implemented in Creature, Guardian, Player, and Totem.

◆ UpdateAuraForGroup()

void Unit::UpdateAuraForGroup ( uint8 slot )

Definition at line 17230 of file Unit.cpp.

{
    if (slot >= MAX_AURAS)                        // slot not found, return
        return;
    if (Player* player = ToPlayer())
    {
        if (player->GetGroup())
        {
            player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_AURAS);
            player->SetAuraUpdateMaskForRaid(slot);
        }
    }
    else if (GetTypeId() == TYPEID_UNIT && IsPet())
    {
        Pet* pet = ((Pet*)this);
        if (pet->isControlled())
        {
            Unit* owner = GetOwner();
            if (owner && (owner->GetTypeId() == TYPEID_PLAYER) && owner->ToPlayer()->GetGroup())
            {
                owner->ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_AURAS);
                pet->SetAuraUpdateMaskForRaid(slot);
            }
        }
    }
}

◆ UpdateCharmAI()

void Unit::UpdateCharmAI ( )

Definition at line 15622 of file Unit.cpp.

{
    if (GetTypeId() == TYPEID_PLAYER)
        return;
 
    if (i_disabledAI) // disabled AI must be primary AI
    {
        if (!IsCharmed())
        {
            delete i_AI;
            i_AI = i_disabledAI;
            i_disabledAI = nullptr;
        }
    }
    else
    {
        if (IsCharmed())
        {
            i_disabledAI = i_AI;
            if (isPossessed() || IsVehicle())
                i_AI = new PossessedAI(ToCreature());
            else
                i_AI = new PetAI(ToCreature());
        }
    }
}

◆ UpdateDamagePhysical()

void Unit::UpdateDamagePhysical ( WeaponAttackType attType )

virtual

Reimplemented in Guardian, and Totem.

Definition at line 60 of file StatSystem.cpp.

{
    float totalMin = 0.f;
    float totalMax = 0.f;
 
    float tmpMin, tmpMax;
    for (uint8 i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
    {
        CalculateMinMaxDamage(attType, false, true, tmpMin, tmpMax, i);
        totalMin += tmpMin;
        totalMax += tmpMax;
    }
 
    switch (attType)
    {
        case BASE_ATTACK:
        default:
            SetStatFloatValue(UNIT_FIELD_MINDAMAGE, totalMin);
            SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, totalMax);
            break;
        case OFF_ATTACK:
            SetStatFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE, totalMin);
            SetStatFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE, totalMax);
            break;
        case RANGED_ATTACK:
            SetStatFloatValue(UNIT_FIELD_MINRANGEDDAMAGE, totalMin);
            SetStatFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, totalMax);
            break;
    }
}

◆ UpdateHeight()

void Unit::UpdateHeight ( float newZ )

Only server-side height update, does not broadcast to client.

Definition at line 20077 of file Unit.cpp.

{
    Relocate(GetPositionX(), GetPositionY(), newZ);
    if (IsVehicle())
        GetVehicleKit()->RelocatePassengers();
}

◆ UpdateInterruptMask()

void Unit::UpdateInterruptMask ( )

Definition at line 758 of file Unit.cpp.

{
    m_interruptMask = 0;
    for (AuraApplicationList::const_iterator i = m_interruptableAuras.begin(); i != m_interruptableAuras.end(); ++i)
        m_interruptMask |= (*i)->GetBase()->GetSpellInfo()->AuraInterruptFlags;
 
    if (Spell* spell = m_currentSpells[CURRENT_CHANNELED_SPELL])
        if (spell->getState() == SPELL_STATE_CASTING)
            m_interruptMask |= spell->m_spellInfo->ChannelInterruptFlags;
}

◆ UpdateMaxHealth()

virtual void Unit::UpdateMaxHealth ( )

pure virtual

Implemented in Creature, Guardian, Player, and Totem.

◆ UpdateMaxPower()

virtual void Unit::UpdateMaxPower ( Powers power )

pure virtual

Implemented in Creature, Guardian, Player, and Totem.

◆ UpdateObjectVisibility()

void Unit::UpdateObjectVisibility	(	bool	forced = `true`,
		bool	fromUpdate = `false`
	)

overridevirtual

Reimplemented from WorldObject.

Definition at line 19162 of file Unit.cpp.

{
    if (!forced)
        AddToNotify(NOTIFY_VISIBILITY_CHANGED);
    else
    {
        WorldObject::UpdateObjectVisibility(true);
        Acore::AIRelocationNotifier notifier(*this);
        float radius = 60.0f;
        Cell::VisitAllObjects(this, notifier, radius);
    }
}

◆ UpdateOrientation()

void Unit::UpdateOrientation ( float orientation )

Only server-side orientation update, does not broadcast to client.

Definition at line 20069 of file Unit.cpp.

{
    SetOrientation(orientation);
    if (IsVehicle())
        GetVehicleKit()->RelocatePassengers();
}

◆ UpdatePosition() [1/2]

bool Unit::UpdatePosition	(	const Position &	pos,
		bool	teleport = `false`
	)

inline

Definition at line 1765 of file Unit.h.

1765{ return UpdatePosition(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation(), teleport); }

◆ UpdatePosition() [2/2]

bool Unit::UpdatePosition	(	float	x,
		float	y,
		float	z,
		float	ang,
		bool	teleport = `false`
	)

virtual

Reimplemented in Player.

Definition at line 20031 of file Unit.cpp.

{
    if (!Acore::IsValidMapCoord(x, y, z, orientation))
        return false;
 
    float old_orientation = GetOrientation();
    float current_z = GetPositionZ();
    bool turn = (old_orientation != orientation);
    bool relocated = (teleport || GetPositionX() != x || GetPositionY() != y || current_z != z);
 
    if (!GetVehicle())
    {
        uint32 mask = 0;
        if (turn) mask |= AURA_INTERRUPT_FLAG_TURNING;
        if (relocated) mask |= AURA_INTERRUPT_FLAG_MOVE;
        if (mask)
            RemoveAurasWithInterruptFlags(mask);
    }
 
    if (relocated)
    {
        if (GetTypeId() == TYPEID_PLAYER)
            GetMap()->PlayerRelocation(ToPlayer(), x, y, z, orientation);
        else
            GetMap()->CreatureRelocation(ToCreature(), x, y, z, orientation);
    }
    else if (turn)
    {
        UpdateOrientation(orientation);
 
        if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetFarSightDistance())
            UpdateObjectVisibility(false);
    }
 
    return (relocated || turn);
}

◆ UpdateReactives()

void Unit::UpdateReactives ( uint32 p_time )

Definition at line 17001 of file Unit.cpp.

{
    for (uint8 i = 0; i < MAX_REACTIVE; ++i)
    {
        ReactiveType reactive = ReactiveType(i);
 
        if (!m_reactiveTimer[reactive])
            continue;
 
        if (m_reactiveTimer[reactive] <= p_time)
        {
            m_reactiveTimer[reactive] = 0;
 
            switch (reactive)
            {
                case REACTIVE_DEFENSE:
                    if (HasAuraState(AURA_STATE_DEFENSE))
                        ModifyAuraState(AURA_STATE_DEFENSE, false);
                    break;
                case REACTIVE_HUNTER_PARRY:
                    if (getClass() == CLASS_HUNTER && HasAuraState(AURA_STATE_HUNTER_PARRY))
                        ModifyAuraState(AURA_STATE_HUNTER_PARRY, false);
                    break;
                case REACTIVE_OVERPOWER:
                    if (getClass() == CLASS_WARRIOR)
                    {
                        ClearComboPoints();
                    }
                    break;
                case REACTIVE_WOLVERINE_BITE:
                    if (IsHunterPet())
                        ClearComboPoints();
                    break;
                default:
                    break;
            }
        }
        else
        {
            m_reactiveTimer[reactive] -= p_time;
        }
    }
}

◆ UpdateResistances()

virtual void Unit::UpdateResistances ( uint32 school )

pure virtual

Implemented in Creature, Player, and Totem.

◆ UpdateSpeed()

void Unit::UpdateSpeed	(	UnitMoveType	mtype,
		bool	forced
	)

Todo:: possible affect only on MOVE_RUN

Definition at line 14135 of file Unit.cpp.

{
    int32 main_speed_mod  = 0;
    float stack_bonus     = 1.0f;
    float non_stack_bonus = 1.0f;
 
    switch (mtype)
    {
        // Only apply debuffs
        case MOVE_FLIGHT_BACK:
        case MOVE_RUN_BACK:
        case MOVE_SWIM_BACK:
        case MOVE_WALK:
            break;
        case MOVE_RUN:
            {
                if (IsMounted()) // Use on mount auras
                {
                    main_speed_mod  = GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_MOUNTED_SPEED);
                    stack_bonus     = GetTotalAuraMultiplier(SPELL_AURA_MOD_MOUNTED_SPEED_ALWAYS);
                    non_stack_bonus += GetMaxPositiveAuraModifier(SPELL_AURA_MOD_MOUNTED_SPEED_NOT_STACK) / 100.0f;
                }
                else
                {
                    main_speed_mod  = GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_SPEED);
                    stack_bonus     = GetTotalAuraMultiplier(SPELL_AURA_MOD_SPEED_ALWAYS);
                    non_stack_bonus += GetMaxPositiveAuraModifier(SPELL_AURA_MOD_SPEED_NOT_STACK) / 100.0f;
                }
                break;
            }
        case MOVE_SWIM:
            {
                // xinef: check for forced_speed_mod of sea turtle
                Unit::AuraEffectList const& swimAuras = GetAuraEffectsByType(SPELL_AURA_MOD_INCREASE_SWIM_SPEED);
                for (Unit::AuraEffectList::const_iterator itr = swimAuras.begin(); itr != swimAuras.end(); ++itr)
                {
                    // xinef: sea turtle only, it is not affected by any increasing / decreasing effects
                    if ((*itr)->GetId() == 64731 /*SPELL_SEA_TURTLE*/)
                    {
                        SetSpeed(mtype, AddPct(non_stack_bonus, (*itr)->GetAmount()), forced);
                        return;
                    }
                    else if (
                        // case: increase speed
                        ((*itr)->GetAmount() > 0 && (*itr)->GetAmount() > main_speed_mod) ||
                        // case: decrease speed
                        ((*itr)->GetAmount() < 0 && (*itr)->GetAmount() < main_speed_mod)
                     )
                    {
                        main_speed_mod = (*itr)->GetAmount();
                    }
                }
                break;
            }
        case MOVE_FLIGHT:
            {
                if (GetTypeId() == TYPEID_UNIT && IsControlledByPlayer()) // not sure if good for pet
                {
                    main_speed_mod  = GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_VEHICLE_FLIGHT_SPEED);
                    stack_bonus     = GetTotalAuraMultiplier(SPELL_AURA_MOD_VEHICLE_SPEED_ALWAYS);
 
                    // for some spells this mod is applied on vehicle owner
                    int32 owner_speed_mod = 0;
 
                    if (Unit* owner = GetCharmer())
                        owner_speed_mod = owner->GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_VEHICLE_FLIGHT_SPEED);
 
                    main_speed_mod = std::max(main_speed_mod, owner_speed_mod);
                }
                else if (IsMounted())
                {
                    main_speed_mod  = GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED);
                    stack_bonus     = GetTotalAuraMultiplier(SPELL_AURA_MOD_MOUNTED_FLIGHT_SPEED_ALWAYS);
                }
                else             // Use not mount (shapeshift for example) auras (should stack)
                    main_speed_mod  = GetTotalAuraModifier(SPELL_AURA_MOD_INCREASE_FLIGHT_SPEED) + GetTotalAuraModifier(SPELL_AURA_MOD_INCREASE_VEHICLE_FLIGHT_SPEED);
 
                non_stack_bonus += GetMaxPositiveAuraModifier(SPELL_AURA_MOD_FLIGHT_SPEED_NOT_STACK) / 100.0f;
 
                // Update speed for vehicle if available
                if (GetTypeId() == TYPEID_PLAYER && GetVehicle())
                    GetVehicleBase()->UpdateSpeed(MOVE_FLIGHT, true);
                break;
            }
        default:
            LOG_ERROR("entities.unit", "Unit::UpdateSpeed: Unsupported move type ({})", mtype);
            return;
    }
 
    // now we ready for speed calculation
    float speed = std::max(non_stack_bonus, stack_bonus);
    if (main_speed_mod)
        AddPct(speed, main_speed_mod);
 
    switch (mtype)
    {
        case MOVE_RUN:
        case MOVE_SWIM:
        case MOVE_FLIGHT:
        {
            // Set creature speed rate
            if (GetTypeId() == TYPEID_UNIT)
                speed *= ToCreature()->GetCreatureTemplate()->speed_run; // at this point, MOVE_WALK is never reached
 
            // Normalize speed by 191 aura SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED if need
            if (int32 normalization = GetMaxPositiveAuraModifier(SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED))
            {
                if (Creature* creature = ToCreature())
                {
                    uint32 immuneMask = creature->GetCreatureTemplate()->MechanicImmuneMask;
                    if (immuneMask & (1 << (MECHANIC_SNARE - 1)) || immuneMask & (1 << (MECHANIC_DAZE - 1)))
                        break;
                }
 
                // Use speed from aura
                float max_speed = normalization / (IsControlledByPlayer() ? playerBaseMoveSpeed[mtype] : baseMoveSpeed[mtype]);
                if (speed > max_speed)
                    speed = max_speed;
            }
            break;
        }
        default:
            break;
    }
 
    int32 slowFromHealth = 0;
    Creature* creature = ToCreature();
    // ignore pets, player owned vehicles, and mobs immune to snare
    if (creature
        && !IsPet()
        && !(IsControlledByPlayer() && IsVehicle())
        && !(creature->HasMechanicTemplateImmunity(MECHANIC_SNARE))
        && !(creature->IsDungeonBoss()))
    {
        // 1.6% for each % under 30.
        // use min(0, health-30) so that we don't boost mobs above 30.
        slowFromHealth = (int32) std::min(0.0f, (1.66f * (GetHealthPct() - 30.0f)));
    }
 
    if (slowFromHealth)
    {
        AddPct(speed, slowFromHealth);
    }
 
    // Apply strongest slow aura mod to speed
    int32 slow = GetMaxNegativeAuraModifier(SPELL_AURA_MOD_DECREASE_SPEED);
    if (slow)
        AddPct(speed, slow);
 
    if (float minSpeedMod = (float)GetMaxPositiveAuraModifier(SPELL_AURA_MOD_MINIMUM_SPEED))
    {
        float base_speed = (GetTypeId() == TYPEID_UNIT ? ToCreature()->GetCreatureTemplate()->speed_run : 1.0f);
        float min_speed = base_speed * (minSpeedMod / 100.0f);
        if (speed < min_speed)
            speed = min_speed;
    }
 
    SetSpeed(mtype, speed, forced);
}

◆ UpdateSplineMovement()

void Unit::UpdateSplineMovement ( uint32 t_diff )

private

Definition at line 593 of file Unit.cpp.

{
    if (movespline->Finalized())
        return;
 
    // xinef: process movementinform
    // this code cant be placed inside EscortMovementGenerator, because we cant delete active MoveGen while it is updated
    SplineHandler handler(this);
    movespline->updateState(t_diff, handler);
    // Xinef: Spline was cleared by StopMoving, return
    if (!movespline->Initialized())
    {
        DisableSpline();
        return;
    }
 
    bool arrived = movespline->Finalized();
 
    if (arrived)
    {
        DisableSpline();
 
        if (movespline->HasAnimation() && GetTypeId() == TYPEID_UNIT && IsAlive())
            SetByteValue(UNIT_FIELD_BYTES_1, UNIT_BYTES_1_OFFSET_ANIM_TIER, movespline->GetAnimationType());
    }
 
    // pussywizard: update always! not every 400ms, because movement generators need the actual position
    //m_movesplineTimer.Update(t_diff);
    //if (m_movesplineTimer.Passed() || arrived)
    UpdateSplinePosition();
}

◆ UpdateSplinePosition()

void Unit::UpdateSplinePosition ( )

private

Definition at line 625 of file Unit.cpp.

{
    //static uint32 const positionUpdateDelay = 400;
 
    //m_movesplineTimer.Reset(positionUpdateDelay);
    Movement::Location loc = movespline->ComputePosition();
 
    if (movespline->onTransport)
    {
        Position& pos = m_movementInfo.transport.pos;
        pos.m_positionX = loc.x;
        pos.m_positionY = loc.y;
        pos.m_positionZ = loc.z;
        pos.SetOrientation(loc.orientation);
 
        if (TransportBase* transport = GetDirectTransport())
            transport->CalculatePassengerPosition(loc.x, loc.y, loc.z, &loc.orientation);
    }
 
    // Xinef: this is bullcrap, if we had spline running update orientation along with position
    //if (HasUnitState(UNIT_STATE_CANNOT_TURN))
    //    loc.orientation = GetOrientation();
 
    if (GetTypeId() == TYPEID_PLAYER)
        UpdatePosition(loc.x, loc.y, loc.z, loc.orientation);
    else
        ToCreature()->SetPosition(loc.x, loc.y, loc.z, loc.orientation);
}

◆ UpdateStats()

virtual bool Unit::UpdateStats ( Stats stat )

pure virtual

Implemented in Creature, Guardian, Player, and Totem.

◆ Whisper() [1/2]

void Unit::Whisper	(	std::string_view	text,
		Language	language,
		Player *	target,
		bool	isBossWhisper = `false`
	)

virtual

Reimplemented in Player.

Definition at line 21158 of file Unit.cpp.

{
    if (!target)
    {
        return;
    }
 
    LocaleConstant locale = target->GetSession()->GetSessionDbLocaleIndex();
    WorldPacket data;
    ChatHandler::BuildChatPacket(data, isBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER, language, this, target, text, 0, "", locale);
    target->SendDirectMessage(&data);
}

◆ Whisper() [2/2]

void Unit::Whisper	(	uint32	textId,
		Player *	target,
		bool	isBossWhisper = `false`
	)

virtual

Reimplemented in Player.

Definition at line 21200 of file Unit.cpp.

{
    if (!target)
    {
        return;
    }
 
    BroadcastText const* bct = sObjectMgr->GetBroadcastText(textId);
    if (!bct)
    {
        LOG_ERROR("entities.unit", "Unit::Whisper: `broadcast_text` was not {} found", textId);
        return;
    }
 
    LocaleConstant locale = target->GetSession()->GetSessionDbLocaleIndex();
    WorldPacket data;
    ChatHandler::BuildChatPacket(data, isBossWhisper ? CHAT_MSG_RAID_BOSS_WHISPER : CHAT_MSG_MONSTER_WHISPER, LANG_UNIVERSAL, this, target, bct->GetText(locale, getGender()), 0, "", locale);
    target->SendDirectMessage(&data);
}

◆ Yell() [1/2]

void Unit::Yell	(	std::string_view	text,
		Language	language,
		WorldObject const *	target = `nullptr`
	)

virtual

Reimplemented in Player.

Definition at line 21148 of file Unit.cpp.

{
    Talk(text, CHAT_MSG_MONSTER_YELL, language, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_YELL), target);
}

◆ Yell() [2/2]

void Unit::Yell	(	uint32	textId,
		WorldObject const *	target = `nullptr`
	)

virtual

Reimplemented in Player.

Definition at line 21190 of file Unit.cpp.

{
    Talk(textId, CHAT_MSG_MONSTER_YELL, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_YELL), target);
}

Member Data Documentation

◆ _charmThreatInfo

CharmThreatMap Unit::_charmThreatInfo

protected

Definition at line 2525 of file Unit.h.

◆ _instantCast

bool Unit::_instantCast

protected

Definition at line 2537 of file Unit.h.

◆ _isWalkingBeforeCharm

bool Unit::_isWalkingBeforeCharm

private

Are we walking before we were charmed?

Definition at line 2585 of file Unit.h.

◆ _lastDamagedTargetGuid

ObjectGuid Unit::_lastDamagedTargetGuid

private

Definition at line 2591 of file Unit.h.

◆ _lastExtraAttackSpell

uint32 Unit::_lastExtraAttackSpell

private

Definition at line 2589 of file Unit.h.

◆ _lastLiquid

LiquidTypeEntry const* Unit::_lastLiquid

protected

Definition at line 2531 of file Unit.h.

◆ _oldFactionId

uint32 Unit::_oldFactionId

private

faction before charm

Definition at line 2584 of file Unit.h.

◆ _redirectThreatInfo

RedirectThreatInfo Unit::_redirectThreatInfo

private

Definition at line 2579 of file Unit.h.

◆ bRequestForcedVisibilityUpdate

bool Unit::bRequestForcedVisibilityUpdate

Definition at line 2408 of file Unit.h.

◆ extraAttacksTargets

std::unordered_map<ObjectGuid , uint32 > Unit::extraAttacksTargets

private

Definition at line 2590 of file Unit.h.

◆ i_AI

UnitAI* Unit::i_AI

protected

Definition at line 2464 of file Unit.h.

◆ i_disabledAI

UnitAI * Unit::i_disabledAI

protected

Definition at line 2464 of file Unit.h.

◆ i_motionMaster

MotionMaster* Unit::i_motionMaster

protected

Definition at line 2518 of file Unit.h.

◆ IsAIEnabled

bool Unit::IsAIEnabled

Definition at line 2345 of file Unit.h.

◆ m_appliedAuras

AuraApplicationMap Unit::m_appliedAuras

protected

Definition at line 2497 of file Unit.h.

◆ m_applyResilience

bool Unit::m_applyResilience

protected

Definition at line 2534 of file Unit.h.

◆ m_attackers

AttackerSet Unit::m_attackers

protected

Definition at line 2480 of file Unit.h.

◆ m_attacking

Unit* Unit::m_attacking

protected

Definition at line 2481 of file Unit.h.

◆ m_attackTimer

int32 Unit::m_attackTimer[MAX_ATTACK]

protected

Definition at line 2476 of file Unit.h.

◆ m_auraModifiersGroup

float Unit::m_auraModifiersGroup[UNIT_MOD_END][MODIFIER_TYPE_END]

protected

Definition at line 2508 of file Unit.h.

◆ m_auraStateAuras

AuraStateAurasMap Unit::m_auraStateAuras

protected

Definition at line 2505 of file Unit.h.

◆ m_auraUpdateIterator

AuraMap::iterator Unit::m_auraUpdateIterator

protected

Definition at line 2499 of file Unit.h.

◆ m_AutoRepeatFirstCast

bool Unit::m_AutoRepeatFirstCast

protected

Definition at line 2474 of file Unit.h.

◆ m_baseSpellCritChance

int32 Unit::m_baseSpellCritChance

Definition at line 2085 of file Unit.h.

◆ m_canDualWield

bool Unit::m_canDualWield

Definition at line 1356 of file Unit.h.

◆ m_canModifyStats

bool Unit::m_canModifyStats

protected

Definition at line 2510 of file Unit.h.

◆ m_charmInfo

CharmInfo* Unit::m_charmInfo

protected

Definition at line 2515 of file Unit.h.

◆ m_cleanupDone

bool Unit::m_cleanupDone

private

Definition at line 2581 of file Unit.h.

◆ m_CombatTimer

uint32 Unit::m_CombatTimer

private

Definition at line 2565 of file Unit.h.

◆ m_ComboPointHolders

std::unordered_set<Unit*> Unit::m_ComboPointHolders

private

Definition at line 2577 of file Unit.h.

◆ m_comboPoints

int8 Unit::m_comboPoints

private

Definition at line 2576 of file Unit.h.

◆ m_comboTarget

Unit* Unit::m_comboTarget

private

Definition at line 2575 of file Unit.h.

◆ m_Controlled

ControlSet Unit::m_Controlled

Definition at line 1864 of file Unit.h.

◆ m_ControlledByPlayer

bool Unit::m_ControlledByPlayer

Definition at line 2357 of file Unit.h.

◆ m_CreatedByPlayer

bool Unit::m_CreatedByPlayer

Definition at line 2358 of file Unit.h.

◆ m_createStats

float Unit::m_createStats[MAX_STATS]

protected

Definition at line 2478 of file Unit.h.

◆ m_currentSpells

Spell* Unit::m_currentSpells[CURRENT_MAX_SPELL]

protected

Definition at line 2494 of file Unit.h.

◆ m_deathState

DeathState Unit::m_deathState

protected

Definition at line 2483 of file Unit.h.

◆ m_delayed_unit_ai_notify_timer

uint16 Unit::m_delayed_unit_ai_notify_timer

Definition at line 2407 of file Unit.h.

◆ m_delayed_unit_relocation_timer

uint16 Unit::m_delayed_unit_relocation_timer

Definition at line 2406 of file Unit.h.

◆ m_Diminishing

Diminishing Unit::m_Diminishing

private

Definition at line 2569 of file Unit.h.

◆ m_duringRemoveFromWorld

bool Unit::m_duringRemoveFromWorld

private

Definition at line 2582 of file Unit.h.

◆ m_dynObj

DynObjectList Unit::m_dynObj

protected

Definition at line 2488 of file Unit.h.

◆ m_Events

EventProcessor Unit::m_Events

Definition at line 2091 of file Unit.h.

◆ m_extraAttacks

uint32 Unit::m_extraAttacks

Definition at line 1355 of file Unit.h.

◆ m_FollowingRefMgr

FollowerRefMgr Unit::m_FollowingRefMgr

private

Definition at line 2573 of file Unit.h.

◆ m_gameObj

GameObjectList Unit::m_gameObj

protected

Definition at line 2491 of file Unit.h.

◆ m_HostileRefMgr

HostileRefMgr Unit::m_HostileRefMgr

private

Definition at line 2571 of file Unit.h.

◆ m_interruptableAuras

AuraApplicationList Unit::m_interruptableAuras

protected

Definition at line 2504 of file Unit.h.

◆ m_interruptMask

uint32 Unit::m_interruptMask

protected

Definition at line 2506 of file Unit.h.

◆ m_last_notify_mstime

uint32 Unit::m_last_notify_mstime

Definition at line 2405 of file Unit.h.

◆ m_last_notify_position

Position Unit::m_last_notify_position

Definition at line 2404 of file Unit.h.

◆ m_lastManaUse

uint32 Unit::m_lastManaUse

private

Definition at line 2566 of file Unit.h.

◆ m_lastSanctuaryTime

uint32 Unit::m_lastSanctuaryTime

Definition at line 2134 of file Unit.h.

◆ m_modAttackSpeedPct

float Unit::m_modAttackSpeedPct[3]

Definition at line 2088 of file Unit.h.

◆ m_modAuras

AuraEffectList Unit::m_modAuras[TOTAL_AURAS]

protected

Definition at line 2502 of file Unit.h.

◆ m_modMeleeHitChance

float Unit::m_modMeleeHitChance

Definition at line 2082 of file Unit.h.

◆ m_modRangedHitChance

float Unit::m_modRangedHitChance

Definition at line 2083 of file Unit.h.

◆ m_modSpellHitChance

float Unit::m_modSpellHitChance

Definition at line 2084 of file Unit.h.

◆ m_movedByPlayer

SafeUnitPointer Unit::m_movedByPlayer

Definition at line 1885 of file Unit.h.

◆ m_ObjectSlot

ObjectGuid Unit::m_ObjectSlot[MAX_GAMEOBJECT_SLOT]

Definition at line 2066 of file Unit.h.

◆ m_ownedAuras

AuraMap Unit::m_ownedAuras

protected

Definition at line 2496 of file Unit.h.

◆ m_petAuras

PetAuraSet Unit::m_petAuras

Definition at line 2329 of file Unit.h.

◆ m_procDeep

int32 Unit::m_procDeep

protected

Definition at line 2485 of file Unit.h.

◆ m_race

uint8 Unit::m_race

protected

Definition at line 2472 of file Unit.h.

◆ m_reactiveTimer

uint32 Unit::m_reactiveTimer[MAX_REACTIVE]

protected

Definition at line 2520 of file Unit.h.

◆ m_realRace

uint8 Unit::m_realRace

protected

Definition at line 2471 of file Unit.h.

◆ m_regenTimer

int32 Unit::m_regenTimer

protected

Definition at line 2521 of file Unit.h.

◆ m_removedAuras

AuraList Unit::m_removedAuras

protected

Definition at line 2498 of file Unit.h.

◆ m_removedAurasCount

uint32 Unit::m_removedAurasCount

protected

Definition at line 2500 of file Unit.h.

◆ m_rootTimes

uint32 Unit::m_rootTimes

protected

Definition at line 2561 of file Unit.h.

◆ m_scAuras

AuraList Unit::m_scAuras

protected

Definition at line 2503 of file Unit.h.

◆ m_sharedVision

SharedVisionList Unit::m_sharedVision

protected

Definition at line 2516 of file Unit.h.

◆ m_speed_rate

float Unit::m_speed_rate[MAX_MOVE_TYPE]

protected

Definition at line 2513 of file Unit.h.

◆ m_spellImmune

SpellImmuneList Unit::m_spellImmune[MAX_SPELL_IMMUNITY]

Definition at line 2133 of file Unit.h.

◆ m_state

uint32 Unit::m_state

private

Definition at line 2564 of file Unit.h.

◆ m_SummonSlot

ObjectGuid Unit::m_SummonSlot[MAX_SUMMON_SLOT]

Definition at line 2065 of file Unit.h.

◆ m_ThreatMgr

ThreatMgr Unit::m_ThreatMgr

protected

Definition at line 2523 of file Unit.h.

◆ m_threatModifier

float Unit::m_threatModifier[MAX_SPELL_SCHOOL]

Definition at line 2087 of file Unit.h.

◆ m_transform

uint32 Unit::m_transform

protected

Definition at line 2492 of file Unit.h.

◆ m_unitTypeMask

uint32 Unit::m_unitTypeMask

protected

Definition at line 2530 of file Unit.h.

◆ m_vehicle

Vehicle* Unit::m_vehicle

protected

Definition at line 2527 of file Unit.h.

◆ m_vehicleKit

Vehicle* Unit::m_vehicleKit

protected

Definition at line 2528 of file Unit.h.

◆ m_visibleAuras

VisibleAuraMap Unit::m_visibleAuras

protected

Definition at line 2511 of file Unit.h.

◆ m_weaponDamage

float Unit::m_weaponDamage[MAX_ATTACK][MAX_WEAPON_DAMAGE_RANGE][MAX_ITEM_PROTO_DAMAGES]

protected

Definition at line 2509 of file Unit.h.

◆ movespline

Movement::MoveSpline* Unit::movespline

Definition at line 2435 of file Unit.h.

◆ NeedChangeAI

bool Unit::NeedChangeAI

Definition at line 2345 of file Unit.h.

◆ SafeUnitPointerSet

std::set<SafeUnitPointer*> Unit::SafeUnitPointerSet

Definition at line 2399 of file Unit.h.

The documentation for this class was generated from the following files:

D:/azerothcore-wotlk/src/server/game/Entities/Unit/Unit.h
D:/azerothcore-wotlk/src/server/game/Entities/Object/Object.cpp
D:/azerothcore-wotlk/src/server/game/Entities/Unit/StatSystem.cpp
D:/azerothcore-wotlk/src/server/game/Entities/Unit/Unit.cpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ AttackerSet

◆ AuraApplicationList

◆ AuraApplicationMap

◆ AuraApplicationMapBounds

◆ AuraApplicationMapBoundsNonConst

◆ AuraEffectList

◆ AuraList

◆ AuraMap

◆ AuraMapBounds

◆ AuraMapBoundsNonConst

◆ AuraStateAurasMap

◆ AuraStateAurasMapBounds

◆ CharmThreatMap

◆ ComboPointHolderSet

◆ ControlSet

◆ Diminishing

◆ DynObjectList

◆ GameObjectList

◆ PetAuraSet

◆ VisibleAuraMap

Constructor & Destructor Documentation

◆ ~Unit()

◆ Unit()

Member Function Documentation

◆ _addAttacker()

◆ _AddAura()

◆ _ApplyAllAuraStatMods()

◆ _ApplyAura()

◆ _ApplyAuraEffect()

◆ _CreateAuraApplication()

◆ _DeleteRemovedAuras()

◆ _EnterVehicle()

◆ _ExitVehicle()

◆ _IsNoStackAuraDueToAura()

◆ _IsValidAssistTarget()

◆ _IsValidAttackTarget()

◆ _RegisterAuraEffect()

◆ _RegisterDynObject()

◆ _RemoveAllAuraStatMods()

◆ _removeAttacker()

◆ _RemoveNoStackAuraApplicationsDueToAura()

◆ _RemoveNoStackAurasDueToAura()

◆ _TryStackingOrRefreshingExistingAura()

◆ _UnapplyAura() [1/2]

◆ _UnapplyAura() [2/2]

◆ _UnregisterDynObject()

◆ _UpdateAutoRepeatSpell()

◆ _UpdateSpells()

◆ AddAura() [1/2]

◆ AddAura() [2/2]

◆ AddComboPointHolder()

◆ AddComboPoints() [1/2]

◆ AddComboPoints() [2/2]

◆ AddExtraAttacks()

◆ AddExtraUnitMovementFlag()

◆ addFollower()

◆ AddGameObject()

◆ addHatedBy()

◆ AddInterruptMask()

◆ AddPetAura()

◆ AddPlayerToVision()

◆ AddPointedBy()

◆ AddSpellCooldown()

◆ AddThreat()

◆ AddToWorld()

◆ AddUnitMovementFlag()

◆ AddUnitState()

◆ AddUnitTypeMask()

◆ ApplyAttackTimePercentMod()